# The Salto Project: Static Analysis of OCaml Programs by Abstract Interpretation

Pierre Lermusiaux, Benoît Montagu

<figure><img src="image_1.png" /></figure>

## To cite this version:

Pierre Lermusiaux, Benoît Montagu. The Salto Project: Static Analysis of OCaml Programs by Abstract Interpretation. ERCIM News, 2024, Special theme: Software Security, October 2024 (139), pp.24. hal-04769799

HAL Id: hal-04769799

https://hal.science/hal-04769799v1

Submitted on 6 Nov 2024

HAL is a multi-disciplinary open access archive for the deposit and dissemination of scientific research documents, whether they are published or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

<figure><img src="image_2.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
ERCIM

<figure><img src="image_3.png" /></figure>

NEWS

0100110001110000000100
11011011110101010000101
1001SPECIAL011100101000
001001100001101THEME011
11010010101001100010000
000100010000000001100
1011SOFTWARE01001111011
0110001101110110111011
00010000SECURITY1110010
1011110000101000001001
10111010111001010111010

Also in this issue's Research and Innovation section:
Sustainable Agriculture through Industry 5.0 Technologies
# Editorial Information

ERCIM News is the magazine of ERCIM. Published quarterly, it reports on joint actions of the ERCIM partners, and aims to reflect the contribution made by ERCIM to the European Community in Information Technology and Applied Mathematics. Through short articles and news items, it provides a forum for the exchange of information between the institutes and also with the wider scientific community. This issue has a circulation of about 2,000 printed copies and is also available online, at https://ercim-news@ercim.eu.

ERCIM News is published by ERCIM EEIG

BP 93, F-06902 Sophia Antipolis Cedex, France

+33 4 9238 5010, contact@ercim.eu

Director: Dominique Hazaël-Massieux, ISSN 0926-4981

## Contributions

Contributions should be submitted to the local editor of your country

## Copyright notice

All authors, as identified in each article, retain copyright of their work.

ERCIM News is licensed under a Creative Commons Attribution 4.0 International License (CC-BY).

## Advertising

For current advertising rates and conditions, see

https://ercim-news.ercim.eu/ or contact peter.kunz@ercim.eu

ERCIM News online edition: https://ercim-news.ercim.eu/

## Next issue:

January 2024: Large-Scale Data Analytics

## Subscription

Subscribe to ERCIM News by sending an email to en-subscriptions@ercim.eu

## Editorial Board:

Central editor: Peter Kunz, ERCIM office (peter.kunz@ercim.eu)

## Local Editors:

* Ferran Argelaguet, Inria, France (ferran.argelaguet@inria.fr)

* Andras Benczur, SZTAKI, Hungary (benczur@info.ilab.sztaki.hu)

* Cecilia Hyrén, RISE, Sweden (cecilia.hyren@ri.se)

* José Borbinha, Univ. of Technology Lisboa, Portugal (jlb@ist.utl.pt)

* Are Magnus Bruaset, SIMULA, Norway (arem@simula.no)

* Monica Divitini, NTNU, Norway (divitini@ntnu.no)

* Marie-Claire Forgue, ERCIM/W3C (mcf@w3.org)

* Lida Harami, ICS-FORTH, Greece (lida@ics.forth.gr)

* Athanasios Kalogeras, ISI, Greece (kalogeras@isi.gr)

* Georgia Kapitsaki, Univ. of Cyprus, Cyprus (gkapi@cs.ucy.ac.cy)

* Annette Kik, CWI, The Netherlands (Annette.Kik@cwi.nl)

* Hung Son Nguyen, Univ. of Warsaw, Poland (son@mimuw.edu.pl)

* Alexander Nouak, Fraunhofer-Gesellschaft, Germany (alexander.nouak@iuk.fraunhofer.de)

* Laura Panizo, University of Malaga (laurapanizo@uma.es)

* Erwin Schoitsch, AIT, Austria (erwin.schoitsch@ait.ac.at)

* Thomas Tamisier, LIST, Luxembourg (thomas.tamisier@list.lu)

* Maurice ter Beek, CNR-ISTI, Italy (maurice.terbeek@isti.cnr.it)

# JOINT ERCIM ACTIONS

## 4 29th International Conference on Formal Methods for Industrial Critical Systems (FMICS'24)

by Maurice ter Beek (CNR-ISTI)

## 5 12th International Workshop on Computational Intelligence for Multimedia Understanding

by Behçet Uğur Töreyin (İTÜ), Maria Trocan (ISEP) and Davide Moroni (CNR-ISTI)

## 6 ERCIM "Alain Bensoussan" Fellowship Programme

## 7 Cor Baayen Early Career Researcher Award 2024

# SPECIAL THEME

## Introduction to the Special Theme

### 8 Software Security

by Sebastian Schrittwieser (University of Vienna) and Michele Ianni (University of Calabria)

## Artificial Intelligence for Software Protection

### 8 Next Generation Vulnerability Detection with LLMs

by Mila Dalla Preda, Niccolò Marastoni, Federica Paci (University of Verona)

### 9 Increased Software Security with Large Language Models

by Zoltán Ságodi (University of Szeged), Péter Hegedűs (University of Szeged), and Rudolf Ferenc (University of Szeged)

### 11 AI-Driven Software Security: Vulnerability Detection, Patching, and Anti-Fuzzing

by Aayush Garg, Yuejun Guo and Qiang Tang (Luxembourg Institute of Science and Technology)

### 12 A Proposal for Privacy-preserving Ransomware Detection by means of Federated Machine Learning

by Giovanni Ciaramella (IMT School for Advanced Studies Lucca and CNR-IIT), Fabio Martinelli (CNR-IIT), and Francesco Mercaldo (University of Molise and CNR-IIT)

## Architectural Security and Risk Analysis

### 16 Vulnerability of Software Package Repositories: PyPI, Maven and rpm

by Daniel Setó-Rey, Carlos López-Nozal, and José Ignacio Santos-Martín (Universidad de Burgos)

### 17 Uninstallable by Design: The Role of Pre-installed Apps in Android's Security Landscape

by Thomas Sutter (University of Bern and Zurich University of Applied Sciences), Ariane Trammell (Zurich University of Applied Sciences), and Timo Kehrer (University of Bern)

### 19 Towards Cyber Security Risk Analysis for Digital Products

by Christophe Ponsard and Jean-François Daune (CETIC)

### 20 Challenges for the Secure Integration of Drones into Warehouse Logistics of SMEs

by Peter Kieseberg (St. Pölten UAS), Christoph Kaltenriner (Dataphone GmbH), and Peter Gallistl (Dataphone GmbH)
**21 Enhancing IoT Security Across the Supply Chain**
by Ramon Barakat, Sascha Hackel (Fraunhofer FOKUS) and Miltiadis Siavvas (CERTH)

Code Analysis

**23 Towards Safer Software: Exploring Validation Techniques for Rust Binaries**

by Antonis Louka (University of Cyprus), Andreas Dionysiou (Frederick University), and Elias Athanasopoulos (University of Cyprus)

**24 The Salto Project: Static Analysis of OCaml Programs by Abstract Interpretation**

by Pierre Lermusiaux and Benoît Montagu (Inria)

**26 Generating Mixed Boolean-Arithmetic Expressions through Equality Saturation**

by Caroline Lawitschka and Sebastian Schrittwieser
(University of Vienna)

**27 GLITCH: Polyglot Code Smell Detection in Infrastructure as Code**

by Nuno Saavedra, João F. Ferreira (INESC-ID and University of Lisbon) and Alexandra Mendes (INESC TEC and University of Porto)

**29 Comparability of Software Metrics and Estimating the Strength of Software Protections**

by Patrick Kochberger, Philipp Haindl (St. Pölten
University of Applied Sciences), Matteo Battaglin and
Patrick Felbauer (University of Vienna)

**30 Interactive Fuzzing Reveals Zero-Day Vulnerabilities in Several MQTT Brokers**

by Steffen Lüdtke, Roman Kraus and Martin Schneider
(Fraunhofer FOKUS)

**31 Verifying Code Correctness of Protected Software through Translation Validation**

by Sebastian Schrittwieser (University of Vienna)

Hardware-Assisted Protections

**33 A Framework for the Analysis of Physical Unclonable Function Interfaces**

by Chenglu Jin (CWI) and Marten van Dijk (CWI and Vrije Universiteit)

**34 Enhancing Software Security in Hardware SoC Environments: A Heterogeneous Approach**

by Radhen Hendarmawan (RISE)

**35 Side-Channel Resistant Applications through Co-designed Hardware/ Software: the SCRATCHS Project**

by Frédéric Besson, Célia Le Du (Inria), and Pierre Wilke
(Centrale Supélec Rennes)

**37 Protecting Cryptographic Material in Ethereum Blockchain Clients Using an Open-source Secure Element**

by Mario de la Haba Navarro (Decentralized Security), Pablo Sánchez-Serrano (University of Malaga), and Isaac Agudo (Decentralized Security and University of Malaga)

## RESEARCH AND INNOVATION

**39 Connected Aquaponics: Sustainable Agriculture through Industry 5.0 Technologies and Circular Economy Principles**

by Rafael Kupsa, Amin Anjomshoa and Markus Tauber
(Research Studios Austria)

**41 An Innovative Approach to Supporting Startups in Greece and Southern Europe**

by Panagiotis Konstantinopoulos, Vasileios Loukopoulos, Dionysia Mylona, Maria Veneri, and Konstantinos Bastas (Patras Science Park S.A.)

**43 Boosting MATE Security through Small Language Models**

by Luca Caviglione (CNR-IMATI), Gianluigi Folino (CNR-ICAR), Massimo Guarascio (CNR-ICAR), and Paolo Zicari (CNR-ICAR)

**44 Strengthening Cyber Defence through Cooperative Development and Shared Expertise in Incident Response Playbooks**

by Mehdi Akbari Gurabi, Lasse Nitz, Charukeshi Mayuresh Joglekar, and Avikarsha Mandal (Fraunhofer FIT)

**47 Unlocking the Future: A Cloud-Based Artificial Intelligence Access Control System**

by Hamidreza Yaghoubi, Navtaj Randhawa (University of Applied Sciences Burgenland), and Igor Ivkić (University of Applied Sciences Burgenland and Lancaster University, UK)

**49 Engineering Secure, Trustworthy, and Ethically Sound AI-Based Computer Systems**

by Yasin Ghafourian (Research Studios Austria), Markus Tauber (Research Studios Austria), Germar Schneider, and Andrea Bannert (Infineon Technologies Dresden GmbH & Co. KG), Olga Kattan (Philips), and Erwin Schoitsch (Austrian Institute of Technology)

**50 Identity and the Web**

by Simone Onofri (W3C)

**52 Advancing Research: The Role of the EOSC and EOSC Support Office Austria**

by Katharina Flicker (EOSC Support Office Austria, SBA Research, TU Wien), Stefan Hanslik (BMBWF), Tereza Kalová (Vienna University Library, University of Vienna)

## ANNOUNCEMENTS / IN BRIEF

**38 ACM Digital Threats: Research and Practice**

**54 Dagstuhl Seminars and Perspectives Workshops**

**54 Towards a Shared AI Strategy for European Digital Science Institutes and Organisations**

**55 Horizon Europe Project Management**

**55 In Memoriam: Prof. Dr. rer. pol. Matthias Jarke (1952–2024)**
# 29th International Conference on Formal Methods for Industrial Critical Systems (FMICS'24)

by Maurice ter Beek (CNR-ISTI)

The yearly conference of the ERCIM Working Group on Formal Methods for Industrial Critical Systems, FMICS [L1], the key conference at the intersection of industrial applications and formal methods, reached its 29th edition. This year the participants met in Milan, Italy, during 9-11 September 2024.

The aim of the FMICS conference series is to provide a forum for researchers and practitioners interested in the development and application of formal methods in industry. It strives to promote research and development for improving formal methods and tools for industrial applications.

FMICS 2024 [L2] was chaired by Anne Haxthausen (Technical University of Denmark, Lyngby) and Wendelin Serwe (Inria Grenoble, France) and organised by the general chairs Matteo Pradella and Matteo Rossi (Politecnico di Milano, Italy) and their team as a co-located event of FM 2024, the 26th International Symposium on Formal Methods. As part of this co-location, FM and FMICS organised a joint Industry Day on 11 September. This is one of the reasons for which FMICS 2024 overall attracted about 100 participants from many countries worldwide, from academia as well as industry, making this a very well attended edition.

The international program committee, with 35 members from 15 different countries, received 22 submissions and decided to accept 14 papers after a rigorous reviewing process. The program moreover included two excellent invited keynote presentations, namely “The Business of Proof” by Byron Cook (Amazon Web Services, UK) and “B+ or how to model system properties in a formal software model” by Thierry Lecomte (Clearsy, France), both of which attracted many participants also from FM and from the other co-located conferences FACS, LOPSTR, PPDP and TAP. ERCIM and Inria generously sponsored the invited speakers (Figure 1).

<figure><img src="image_4.png" /><figcaption>Figure 1: FMICS 2024 PC chairs Anne Haxthausen and Wendelin Serwe acknowledged ERCIM sponsoring of the invited speakers during the conference opening presentation.</figcaption></figure>

<figure><img src="image_5.png" /><figcaption>Figure 2: Jan Steffen Becker received the FMICS 2024 Best Paper Award from the PC chairs Anne Haxthausen and Wendelin Serwe.</figcaption></figure>

<figure><img src="image_6.png" /><figcaption>Figure 3: John Hatcliff received the FMICS 2024 Best Tool Paper Award from the PC chairs Anne Haxthausen and Wendelin Serwe.</figcaption></figure>
Following a tradition established over the years, Springer sponsored the FMICS best paper awards. This year, the program committee selected the contributions "Safe Linear Encoding of Vehicle Dynamics for the Instantiation of Abstract Scenarios" by Jan Steffen Becker (German Aerospace Center, Oldenburg) as the FMICS 2024 Best Paper (Figure 2) and "Logika: The Sireum Verification Framework" by Robby, John Hatcliff and Jason Belt (Kansas State University, USA) as the FMICS 2024 Best Tool Paper (Figure 3).

FMICS 2025 will take place in Aarhus, Denmark, under the CONFEST 2025 umbrella, alongside CONCUR, FORMATS and QEST, and organised by the general chairs Jaco van de Pol and Andreas Pavlogiannis (University of Aarhus, Denmark) and their team during 25-30 August 2025.

**Links:**

[L1] https://fmics.inria.fr/

[L2] https://fmics.inria.fr/2024/

**Reference:**

[1] A.E. Haxthausen and W. Serwe (eds.), Formal Methods for Industrial Critical Systems: Proceedings of the 29th International Conference on Formal Methods for Industrial Critical Systems (FMICS'24), Milan, Italy, 9-11 September 2024. Lecture Notes in Computer Science, volume 14952, Springer, Cham, 2024. DOI: https://link.springer.com/book/10.1007/978-3-031-68150-9

**Please contact:**

Maurice ter Beek, CNR-ISTI, maurice.terbeek@isti.cnr.it

# 12th International Workshop on Computational Intelligence for Multimedia Understanding

by Behçet Uğur Töreyin (İTÜ), Maria Trocan (ISEP) and Davide Moroni (CNR-ISTI)

Approximately forty researchers attended the International Workshop on Computational Intelligence for Multimedia Understanding (IWCIM), organized annually by the ERCIM Working Group Multimedia Understanding through Semantics, Computation and Learning (MUSCLE). The workshop took place as a satellite event of IEEE ISCAS 2024 held in Singapore on 21 May 2024.

Multimedia understanding is an essential part of many intelligent applications in our daily lives, whether in our households or commercial, industrial, service, and scientific environments. Analyzing data acquired from a multitude of multimodal sensors to provide them with semantics is essential to exploit their full potential. Multimodal and cross-modal analyses are essential for maximizing their utility.

Through IWCIM, the MUSCLE Working Group [L2] aims to address these emergent topics by growing a community of scientists and practitioners from the academy and industry. The mission continues with the planning of the upcoming thirteenth IWCIM, details of which will be announced shortly.

The IWCIM 2024 website is hosted by Istanbul Technical University [L1], and full-text papers may be accessed via IEEE Xplore.

<figure><img src="image_7.png" /></figure>

<figure><img src="image_8.png" /><figcaption>Highlights from the venue.</figcaption></figure>

We are excited to announce that the next edition will be featured as a special session during IEEE ISCAS 2025, which will take place in London from May 25th to 28th, 2025.

**Links:**

[L1] https://iwcim.itu.edu.tr/technical.html

[L2] https://wiki.ercim.eu/wg/MUSCLE/

**Please contact:**

Davide Moroni, CNR-ISTI, davide.moroni@isti.cnr.it
ERCIM “Alain
Bensoussan”
Fellowship
Programme

The ERCIM postdoctoral Fellowship Programme has been established as one of the premier activities of ERCIM. The programme is open to young researchers from all over the world. It focuses on a broad range of fields in Computer Science and Mathematics.

The fellowship scheme also helps young scientists to improve their knowledge of European research structures and networks and to gain more insight into the working conditions of leading European research institutions. The fellowships are of 12 months duration (with a possible extension), spent in one of the ERCIM member institutes.

Where are the fellows hosted?

Only ERCIM members can host fel-
lows. When an ERCIM member is a
consortium the hosting institute might
be any of the consortium's members.
When an ERCIM Member is a fund-
ing organisation, the hosting institute
might be any of their affiliates.
Fellowships are proposed according to
the needs of the member institutes and
the available funding.

The fellows are appointed either by a
stipend (an agreement for a research
training programme) or a working
contract. The type of contract and the

<figure><img src="image_9.png" /></figure>

ERCIM postdoctoral fellowship is an
unmatched opportunity to sharpen
the skill set and knowledge while
being in the research conducive
environment of Europe. This
fellowship has immense potential to
provide accelerated career growth,
increase research cooperation and
knowledge sharing by fostering
collaborations.

<figure><img src="image_10.png" /><figcaption>Amandeep CHEEMA
Former ERCIM Fellow</figcaption></figure>

<figure><img src="image_11.png" /></figure>

monthly allowance/salary depends on
the hosting institute.

ERCIM encourages both researchers
from academic institutions and scien-
tists working in industry to apply.

Why to apply for an ERCIM
Fellowship?

The Fellowship Programme enables bright young scientists from all over the world to work on a challenging problem as fellows of leading European research centers. In addition, an ERCIM fellowship helps widen and intensify the network of personal relations and understanding among scientists. The programme offers the opportunity to ERCIM fellows:

* to work with internationally recognized experts,

* to improve their knowledge about European research structures and networks,

* to become familiarized with working conditions in leading European research centres,

* to promote cross-fertilization and cooperation, through the fellowships, between research groups working in similar areas in different laboratories.

Equal Opportunities

ERCIM is committed to ensuring
equal opportunities and promoting di-
versity. People seeking fellowship
within the ERCIM consortium are not
discriminated against because race,
color, religion, gender, national origin,
age, marital status or disability.

Conditions

Candidates must:

* have obtained a PhD degree during the last eight years (prior to the application year deadline) or be in the last year of the thesis work with an outstanding academic record. Before starting the grant, a proof of the PhD degree will be requested;

• be fluent in English.

Application deadlines

Deadlines for applications are cur-
rently 30 April and 30 September each
year.

Since its inception in 1991, more than
790 fellows have participated in the
program. In 2023, 19 young scientists
began an ERCIM PhD fellowship, and
throughout the year, 63 fellows were
hosted. The Fellowship Program is
named in honor of Alain Bensoussan,
the former president of Inria, one of
the three founding institutes of
ERCIM.

http://fellowship.ercim.eu

<figure><img src="image_12.png" /></figure>

ERCIM allowed me to be part of
a world-leading research
institution while maintaining the
independence needed to
develop a personal and distinct
research profile. The fellowship
gave me the chance to
significantly expand my personal
network by participating to
various scientific events all over
the world.

<figure><img src="image_13.png" /><figcaption>Giacomo SORELLI
Former ERCIM Fellow</figcaption></figure>

<figure><img src="image_14.png" /></figure>
# Nicola Messina
## Winner of the 2024 Cor Baayen Award

Nicola's research is distinguished by its high quality, interdisciplinary approach, and significant impact. His work spans across multiple domains, including Artificial Intelligence, Computer Vision, Deep Learning, and Multimedia Information Retrieval. He has made substantial contributions to both the theoretical and applied aspects of these fields, with measurable scientific and practical outcomes.

During his PhD, Nicola began exploring the ability of neural networks to understand and process relationships between objects in computer vision. He also made important contributions in multimodal artificial intelligence by developing innovative and efficient methods for aligning representations of complex neural networks in both visual and language modalities.

His work in multimedia information retrieval has demonstrated immediate real-world applicability. This is exemplified by VISIONE, a large-scale video search system that won the 2024 international Video Browser Showdown competition and secured second place in 2023. VISIONE has been employed by the Italian national public broadcaster

<figure><img src="image_15.png" /></figure>

Nicola Messina (left) receives the Cor Baayen Award from ERCIM President Björn Levin at the ERCIM Fall Meetings in Budapest on 16 October 2024.

RAI, as part of the AI4Media European project, to facilitate efficient browsing of audiovisual archives.

More recently, he has expanded his research focus to include the application of attentive deep learning techniques for structural health monitoring and the preservation of cultural heritage. This new direction highlights his ability to engage in highly interdisciplinary research and to address complex challenges across different fields.

Nicola's professional experience also includes international collaborations with esteemed European universities and participation in various Italian and European research projects, such as AI4Media, AI4EU, INAROS, AI4CHSites, ADA, and Smart News. In addition to his research, he is involved in teaching and dissemination activities, offering instruction and guidance to students on topics related to deep learning, computer vision, and multimodal processing.

In 2021 and 2022, Dr. Messina received the ISTI Young Researcher Award, recognizing him as one of the top young researchers (under 32 years old) at CNR-ISTI, Italy.

Overall, Dr. Nicola Messina is an outstanding early-career researcher who has achieved remarkable success during his PhD and postdoctoral work, combining scientific innovation with societal and commercial impact.

Nicola Messina is currently employed at the Information Science and Technologies Institute, National Research Council (CNR-ISTI), Italy, where he is associated with the Artificial Intelligence for Multimedia and Humanities Laboratory (AIMH). He received his PhD in 2022 from the University of Pisa, Italy, with a thesis titled "Relational Learning in Computer Vision," supervised by Fabrizio Falchi, Giuseppe Amato, and Marco Avvenuti.

More information about the Cor Baayen Award: https://kwz.me/hDG

# Cor Baayen Early Career Researcher Award 2024

**Winner:**

Nicola Messina, nominated by Fabrizio Falchi, Information Science and Technologies Institute, National Research Council (CNR-ISTI), Italy

**Honorary mentions:**

* Jana Wagemaker, nominated by CWI, The Netherlands

* David Saulpic, nominated by Inria, France

* Błażj Osiński, nominated by University of Warsaw, Poland

**Finalists:**

* Lesly-Ann Daniel, nominated by INRIA, France

* Diogo Barradas, nominated by INESC, Portugal

* António Correia, nominated by INESC, Portugal

* Agustin Zuniga Corrales, nominated by VTT, Finland

* Shadi Shafighi, nominated by University of Warsaw, Poland

**Selection Committee:**

The Selection Committee was composed of Gabriel David (INESC-TEC), Monica Divitini (NTNU - chair of the ERCIM Human Capital Task Group), Anna Gambin (University of Warsaw), Georgia Kapitsaki (University of Cyprus), Bruno Levy (Inria), Kostas Magoutis (FORTH), and Fabrizio Sebastiani (CNR-ISTI).

The decision was unanimous.
Introduction to the special theme

# Software Security

by Sebastian Schrittwieser (University of Vienna) and,
Michele Ianni (University of Calabria)

Software is gaining unprecedented importance in many industries. The automotive sector is a prime example of this massive change: once primarily confined to embedded systems such as engine control units, software now serves as the central interface for almost all vehicle components. Features such as advanced driver assistance systems, information and connectivity services all rely heavily on software. In addition, cost considerations are driving the replacement of hardware components with software equivalents - from analogue switches and buttons being replaced by a central touchscreen with software-based controls, to dedicated hardware sensors such as LIDAR being replaced by vision-based artificial intelligence (AI). This shift not only reduces manufacturing costs, but also enables entirely new business models. Concepts such as over-the-air updates, paid activation of modular features and subscription models are only possible through software-centric approaches.

However, this increased reliance on software brings new security challenges. In so-called Man-At-The-End (MATE) attacks, reverse engineers have full control over the systems on which they execute, analyze, and modify the targeted software. Such attacks pose significant threats to new business models, including unauthorized activation of functionality, software piracy, and intellectual property infringement. Software integrity is also critical. Modified software can lead to unintended side effects, potentially compromising human safety in critical situations. Fundamentally, ensuring robust software security to protect against analysis and modification is not only a business imperative, but also a safety requirement.

Similar to many other domains, AI is already having a significant impact on software security. Large Language Models (LLMs), such as GPT-4, are improving code analysis and semantic understanding of software, leading to remarkable improvements in both speed and quality. These models can automatically generate code documentation, identify vulnerabilities, and suggest optimisations. While research is currently focused on code analysis, the field of software protection is poised to benefit significantly from AI advances in the coming years as well. AI can be used to develop more sophisticated protection strategies, including code diversification - syntactic variations of software copies to prevent so-called class breaks,

where attacking one instance allows adversaries to compromise all other instances as well.

However, AI-driven advances in software security do not come without challenges. Obfuscation, for example, is a widely used technique that AI could enhance in the future. Obfuscation aims to make code harder to understand by transforming its structure, adding irrelevant code, increasing the complexity of the control flow, and encrypting data. The primary goal is to prevent reverse engineering and protect intellectual property. Despite its usefulness in securing software, obfuscation also presents significant challenges. While it provides protection by hiding the inner workings of code, attackers, including malware developers, can weaponise obfuscation techniques. Bad actors can use the same strategies to hide malware, making it harder for security systems to detect and for analysts to understand the intent of the code. Obfuscated malware can evade signature-based detection mechanisms and slow down reverse engineering efforts, creating a dangerous gap in software security.

Similarly, watermarking is another key technique for protecting software, particularly in the fight against piracy and unauthorized copying of programs. By embedding invisible marks in software, developers can trace the origin of pirated copies or unauthorized modifications. This can be crucial in legal disputes or intellectual property enforcement. However, like obfuscation, watermarking is not immune to abuse. In malicious hands, watermarking can be exploited to make compromised software appear to belong to a legitimate source, complicating the attribution process and potentially implicating innocent parties. This illustrates the double-edged nature of many software protection strategies: while they are essential for securing legitimate software, they also present new challenges when adopted by adversaries.

The risks associated with software exploitation are not limited to intellectual property theft or software piracy. Exploitation can lead to serious vulnerabilities that threaten data security, financial stability of companies, and even human safety. A critical problem is the exploitation of zero-day vulnerabilities - previously unknown flaws in software that can be exploited before developers can patch them. These vulnerabilities can be sold or shared among attackers, making them extremely difficult to defend against in real time. Software exploitation, particularly in critical sectors such as automotive, medical or finance, can have catastrophic consequences if attackers are able to manipulate the software to perform unintended actions.

Mitigating these risks requires a multi-layered approach in software security. Patching software and regularly address-
ing known vulnerabilities is a basic defense mechanism. In addition, adopting secure coding practices, where software is designed with security in mind from the outset, can help reduce the attack surface. AI-driven solutions also play an important role in identifying vulnerabilities earlier, allowing for faster patching and response. For example, AI models can sift through massive code bases and pinpoint areas that are likely to contain vulnerabilities based on past patterns. This automation allows developers to focus their efforts on the most critical parts of the software.

One area that remains particularly vulnerable is the Internet of Things (IoT). IoT devices, from smart home appliances to industrial sensors, are notoriously difficult to secure. Many IoT devices are low-cost and designed with limited computing power, which means they lack the robust security features of more sophisticated systems. Moreover, these devices are often not regularly updated, leaving them vulnerable to known vulnerabilities long after they have been discovered. IoT devices are a prime target for attackers because, once compromised, they can be used as an entry point into wider networks or reused in large-scale attacks such as distributed denial of service (DDoS) campaigns. The security challenges associated with IoT are exacerbated by the decentralized nature of these devices and their widespread deployment. Securing the IoT requires cross-industry collaboration, with standards, regulations and lightweight security measures that can be effectively implemented on resource-constrained devices.

Analyzing software for vulnerabilities relies on a variety of techniques. Static analysis, which examines code without executing it, can help identify potential vulnerabilities by analyzing code structure, syntax and control flow. Dynamic analysis, on the other hand, observes software in action and detects runtime vulnerabilities by observing how the software behaves under different conditions. Combining these approaches with techniques such as fuzzing - where random inputs are thrown at the software to discover unexpected behavior - can help uncover vulnerabilities that would otherwise remain hidden. AI and machine learning models are increasingly being used to enhance both static and dynamic analysis, speeding up the process and improving accuracy by detecting subtle signs of potential threats that might elude human analysts.

From a European perspective, the approach to software security and intellectual property protection presents its own unique set of challenges and opportunities. Europe has always placed a strong emphasis on privacy and data protection, as evidenced by regulations such as the General Data Protection Regulation (GDPR). However, while the region leads the way on privacy, it lags behind the US, Japan and

China in most areas of software innovation. Europe needs to increase its focus on defending against MATE attacks and protecting intellectual property, especially as software becomes central to new business models. The example of Skype - a European-developed VoIP software that became a market leader primarily through its innovative technology, but also because of its superior software protection which prevented clones for many years - illustrates how robust security practices can provide a competitive advantage. However, to maintain this edge, Europe must continue to evolve its software security strategies, especially as AI-driven threats become more sophisticated.

Three key EU legislative frameworks—the Digital Operational Resilience Act (DORA), the Network and Information Security Directive 2 (NIS2), and the Cyber Resilience Act (CRA)—have been established to enhance cybersecurity and operational resilience across various sectors. Each of these initiatives emphasizes stringent security requirements for software, including secure development practices, lifecycle management, and risk assessments. Collectively, these frameworks push organizations to adopt more secure software development practices, invest in advanced security technologies, and ensure continuous compliance with evolving regulations. By embedding security into every stage of the development process, organizations not only comply with these regulations but also improve their overall resilience against cyber threats, positioning themselves to navigate the increasingly complex cybersecurity environment effectively. While these regulations represent a crucial step toward enhancing software security, it is more important than ever for organizations to prioritize it. Doing so is essential for safeguarding digital assets and maintaining resilience in an increasingly interconnected world.

The articles in this special theme section offer a comprehensive panorama of the current European research activities in software security and protection. By showcasing a diverse range of studies and innovative approaches, they highlight the ongoing advancements and key developments shaping the future of the field.

**Please contact:**

Sebastian Schrittwieser
sebastian.schrittwieser@univie.ac.at
University of Vienna, Austria

Michele Ianni
University of Calabria, Italy
michele.ianni@unical.it
# Next Generation Vulnerability Detection with LLMs

by Mila Dalla Preda, Niccolò Marastoni, Federica Paci
(University of Verona)

**Ensuring software security starts with detecting vulnerabilities in the early stages of development: while traditional rule-based and machine-learning methods require expert input, Large Language Models (LLMs) are emerging as powerful, autonomous alternatives that could transform the approach to vulnerability detection.**

The detection of vulnerabilities in source code during the early stages of development is crucial for ensuring robust software systems that can resist cybersecurity threats. This is especially true as the number of reported vulnerabilities is dramatically rising every year (see Figure 1). In recent years, several approaches have been proposed to identify security vulnerabilities, but each has its own limitations. Rule-based methods require expert intervention to define rules or patterns indicative of known vulnerabilities. Moreover, the rules must be adjusted to detect new or unknown vulnerabilities. Recently, deep learning-based approaches have emerged as a promising alternative, capable of automatically learning vulnerability patterns without direct expert involvement [1].

Large Language Models (LLMs) have demonstrated significant potential in interpreting and generating code, suggesting the possibility of using them to detect vulnerabilities in code [2]. In this paper, we present the project VULCAN, which aims to investigate whether LLMs, despite not being specifically trained to detect vulnerabilities in code, can effectively identify vulnerabilities in source code.

While most LLM-based vulnerability-detection approaches rely on fine-tuning, VULCAN leverages LLMs' in-context learning capability, allowing them to tackle new tasks without specific training. To harness this capability, it is essential to adopt prompt engineering strategies that design effective natural language instructions to guide the models in detecting vulnerabilities in source code.

There are different prompting strategies: zero-shot, few-shot, and chain-of-thought. With zero-shot prompting, the model only receives the description of the new task to be performed. Few-shot prompting includes examples

of how the task should be executed. Chain-of-thought prompting gives the model a sequence of steps to execute the task.

VULCAN's main goal is to develop a framework (see Figure 1) to create effective prompts for different prompt-engineering strategies and to evaluate and compare their impact on the accuracy of LLMs in detecting vulnerabilities. However, designing effective prompts for each strategy and evaluating the accuracy of LLM in detecting vulnerabilities requires addressing several challenges.

The first challenge is the limit on the number of input tokens for LLMs, which means that programs with many lines of code cannot be directly included in the prompts. It is therefore necessary to design a concise representation of the code that preserves the semantic relationship between the program's instructions, which is crucial for detecting vulnerabilities.

The second challenge is related to designing prompts for few-shot prompting, which requires adopting strategies to select examples that are relevant for identifying vulnerabilities. Inspired by the recent success of using retrieval modules to augment large-scale neural network models, VULCAN will adopt Retrieval-Augmented Generation (RAG) to select se-

<figure><img src="image_16.png" /><figcaption>Figure 1: Published CVE records from 1999 to 2023. Source: https://www.cve.org/About/Metrics</figcaption></figure>

<figure><img src="image_17.png" /><figcaption>Figure 2: VULCAN framework components.</figcaption></figure>
mantically similar examples to a test program to be included in the few-shot prompt. VULCAN will employ different code similarity measures to select the nearest neighbours of a given test program from a dataset of vulnerable programs.

Then, to verify the effectiveness of this method, we will investigate the impact of different code similarity measures, the order of examples, and the number of examples included in the prompt on the accuracy of LLMs in detecting vulnerabilities. On the other hand, the chain-of-thought strategy requires generating prompt models with specific steps to identify vulnerabilities, which differ for each vulnerability type. Therefore, we will explore how the steps for identifying a specific vulnerability type can be automatically generated.

Finally, a main challenge is related to the datasets of vulnerable code to use to assess LLMs' accuracy in detecting source code vulnerabilities. Indeed, existing vulnerability datasets suffer from many issues that impact their usability to assess the accuracy of LLMs in detecting vulnerabilities, including: 1. an unbalanced number of vulnerable and non-vulnerable programs, 2. inaccurate vulnerability labelling, and 3. data duplication [3]. SVEN [L1] is a notable exception; security experts manually labelled the vulnerabilities present in the code samples, but the number of samples is relatively small, which makes it inadequate to properly assess the accuracy of LLMs in vulnerability detection. Therefore, VULCAN will create a new, larger, balanced dataset of vulnerable programs with an accurate vulnerability labelling process.

The VULCAN's framework aims to address the above challenges to allow security analysts and software developers to harness the in-context learning capability of LLMs in detecting software vulnerabilities. As part of the framework, various experiments will be conducted to compare the effectiveness of the prompting strategies with general-use and code LLMs on the created dataset containing vulnerable programs. The VULCAN project will also develop a tool that leverages the LLM and prompting strategy that proves to be the most effective based on experimental results and will integrate it as a plug-in into the Eclipse development environment.

**Links:**

[L1] https://github.com/eth-sri/sven

**References:**

[1] Z. Li, et al., “Vuldeepecker: a deep learning-based system for vulnerability detection,” in: 25th Annual Network and Distributed System Security Symposium (NDSS), 2018.

[2] Y. Guo, et al., “Outside the comfort zone: analysing LLM capabilities in software vulnerability detection,” in Proc. of ESORICS, 2024.

[3] Y. Ding, et al., “Vulnerability detection with code language models: how far are we?,” arXiv preprint arXiv:2403.18624, 2024. https://arxiv.org/abs/2403.18624.

**Please contact:**

Mila Dalla Preda, University of Verona, Italy
mila.dallapreda@univr.it

Federica Paci, University of Verona, Italy
federica.paci@univr.it

# Increased Software Security with Large Language Models

by Zoltán Ságodi (University of Szeged), Péter Hegedűs (University of Szeged), and Rudolf Ferenc (University of Szeged)

> As AI-driven language models increasingly demonstrate their ability to generate and repair source code, the role of human developers faces a profound transformation. This paper explores both the potential and challenges of leveraging these models for programming tasks and vulnerability mitigation, highlighting where human expertise remains essential.

In recent years, Large Language Models (LLMs) such as GPT-4, ChatGPT, and GitHub Copilot have made remarkable strides in various fields, including software development. From generating new code to fixing existing security problems, these models offer promising tools for developers. However, their capabilities are still far from perfect, especially when it comes to real-world applications. We empirically investigated the real-world capabilities of state-of-the-art LLMs in two very common developer tasks: code synthesis and automated vulnerability repair.

We defined and applied a comparison methodology (depicted in Figure 1) to evaluate how state-of-the-art LLMs perform on code synthesis tasks [1]. Code synthesis is the task where, given a natural language specification, a program code is created that implements the defined functionality. Our comparison included ChatGPT and GitHub Copilot, which we evaluated on the Program Synthesis Benchmark [L1]. The functional evaluations showed that out of 25 programming tasks (i.e. algorithmic solutions to a specified problem), ChatGPT could solve 19, while Copilot could solve 13 tasks with a 100% test pass rate on a test suite including 10,000 tests (meaning that a program was considered correct if it passed all the 10,000 tests). Counting the tasks where the generated code achieved at least a 75% test pass rate on the 10,000 cases, we observed that ChatGPT could solve 20, while Copilot could solve 15 programming tasks.

During the human technical evaluation step, which in simpler terms meant to answer questions like “How good and secure is the code?” or “How many problems are present in the generated code?”, the evaluations showed that these models tend to make some minor mistakes, but crucial problems, including potential vulnerabilities, are quite rare. These results are encouraging and might lead to the obvious question: if these models perform so well in synthesising good quality and secure code from human specifications, would they be capable of correcting human-written code as well?

We analysed this question by focusing on how well GPT-4 can fix existing problems in software systems, vulnerabilities (i.e. potential security issues) in particular. Unlike code synthesis, which focuses on generating new code from scratch, this study [2] investigates whether GPT-4 can repair flaws in existing
<figure><img src="image_18.png" /><figcaption>Figure 1: A systematic LLM result comparison methodology.</figcaption></figure>

code – an increasingly crucial task in the world of cybersecurity.

Using a dataset of 46 real-world Java vulnerabilities from the Vul4J repository [L2], we tasked GPT-4 with generating mitigation patches for these vulnerabilities. We performed a prompt engineering step to get the most out of the model. We also included the human factor in multiple layers. Firstly, we made evaluations by hand, so there were human ratings of the model’s performance. Secondly, we used a benchmark that contained real-life human errors and their patches. The functional tests were also included, as the benchmark contained unit tests for every vulnerability.

We tested the vulnerability-fixing capabilities of the model, and we also tested if the model could be used as a code review assistant. We evaluated how well the model can fix vulnerabilities by providing our predefined prompt with the vulnerable code, and we requested the generation of its fixed version. At this point, we applied the changes and ran the tests. The results (see Figure 2) show that, on average, the model can fix 33.33% of the real vulnerabilities.

We also investigated the use case where we do not ask for a full fix, but only a suggestion. In this case, we asked the model to provide us with textual hints on how to fix a problem besides generating a mitigation patch. We evaluated these suggestions with multiple developers and found that, on average, in 56.6% of the cases, GPT-4 could give developers useful hints on how to fix the source code.

While these two studies focus on different aspects of secure software development – code generation and vulnerability repair – they share a common theme: the importance of human oversight. Both studies make it clear that LLMs like ChatGPT, Copilot, and GPT-4 are not yet capable of replacing human developers. Instead, they serve as powerful assistants that can help automate repetitive tasks, which eventually can lead to higher quality and more secure source code.

Looking at the broader picture, LLMs are making impressive strides in automating software development tasks, but there is still a long way to go. While ChatGPT and Copilot show promise in generating new code, and GPT-4 demonstrates potential in repairing vulnerabilities, neither is ready for full autonomy in real-world software development.

One key area for future research and development is improving the functional and technical validity as well as security of LLM-generated code. As the studies suggest, more sophisticated evaluation frameworks are needed to ensure that the code generated by these models meets both functional requirements and technical best practice. This will likely involve integrating automated tools for static analysis, as well as enhancing the models’ understanding of complex software engineering tasks.

Another important direction for future work is better integrating LLM-generated code into existing development and security operations (DevSecOps) workflows. Right now, the code produced by these models often requires significant refinement before it can be deployed. Finding ways to streamline

<figure><img src="image_19.png" /><figcaption>Figure 2: Distribution of vulnerabilities (i) fully fixed (green); (ii) useful fixing guidelines generated (red); (iii) cannot be fixed (grey) by GPT-4.</figcaption></figure>
this process – either by improving the models’ output or by developing tools that assist with post-processing – will be critical to making LLMs more useful in real-world development environments.

This research received support from the European Union project RRF-2.3.1-21-2022-00004 within the framework of the Artificial Intelligence National Laboratory.

**Links:**

[L1] https://kwz.me/hDv

[L2] https://github.com/tuhh-softsec/vul4j

**References:**

[1] Z. Ságodi, I. Siket, R. Ferenc, "Methodology for code synthesis evaluation of LLMs presented by a case study of ChatGPT and copilot," IEEE Access, vol. 12, pp. 72303-72316, 2024. doi: 10.1109/ACCESS.2024.3403858

[2] Z. Ságodi, et al., "Reality check: assessing GPT-4 in fixing real-world software vulnerabilities," in Proc. of the 28th Int. Conf. on Evaluation and Assessment in Software Engineering, pp. 252-261, 2024.

**Please contact:**

Péter Hegedűs, University of Szeged, Hungary
hpeter@inf.u-szeged.hu

# AI-Driven Software Security: Vulnerability Detection, Patching, and Anti-Fuzzing

by Aayush Garg, Yuejun Guo and Qiang Tang (Luxembourg Institute of Science and Technology)

Artificial Intelligence (AI) is revolutionizing software security within the DevSecOps framework by embedding automated tools for real-time vulnerability detection, patching, and anti-fuzzing into the development pipeline. The LAZARUS project at the Luxembourg Institute of Science and Technology (LIST) is leading this transformation, leveraging advanced AI models to proactively identify and address security threats before they can be exploited.

AI is transforming the way we approach software security, particularly within the DevSecOps framework, where security practices are integrated throughout the development lifecycle. As software systems become more complex and integral to our daily lives, the need for robust security measures has never been more critical. Traditional security methods, often implemented at the end of the development process, are no longer sufficient to address the sophisticated and fast-evolving threats that developers face today. At the Luxembourg Institute of Science and Technology (LIST), we are addressing these challenges through the pPlatform for Analysis of Resilient and secUre Software (LAZARUS) project [L1], which focuses on enhancing software security by embedding AI-driven tools into Continuous Integration/Continuous Deployment (CI/CD) pipelines.

One of the primary innovations of the LAZARUS project is the use of AI for real-time vulnerability detection. By integrating AI models directly into the DevSecOps pipeline, as illustrated in Figure 1, we enable continuous monitoring of code as it is written and integrated. These models, built upon advanced large language models (LLMs) like CodeLLama, using vast datasets, are designed to predict vulnerabilities at the function level, allowing for early detection and immediate action. This proactive approach ensures that vulnerabilities are identified

and addressed before they can be exploited, significantly reducing the risk of security breaches [1].

In addition to vulnerability prediction, the LAZARUS project also focuses on automating the patching process. Patching is a critical component of software maintenance, yet it often lags behind the discovery of vulnerabilities due to the manual effort involved. Our AI-driven patching tool, built on advanced AI models like CodeT5, automatically generates patches for identified vulnerabilities. This tool not only ensures that vulnerabilities are quickly remedied but also maintains the functionality of the original code. By automating patch generation and integration into the CI/CD pipeline, we ensure that security patches are applied immediately, reducing the window of opportunity for potential attackers [1].

<figure><img src="image_20.png" /><figcaption>Figure 1: DevSecOps pipeline [L2].</figcaption></figure>

Another significant challenge in software security is defending against fuzzing attacks. Fuzzing is a technique used by attackers to discover vulnerabilities by sending unexpected or malformed inputs to software APIs. In response, the LAZARUS project has developed an AI-based anti-fuzzing tool. This tool utilises Deep Learning (DL) models to classify and identify the origin of fuzzing inputs in real-time, allowing for immediate and targeted defences. By continuously monitoring incoming data and classifying these inputs based on their characteristics, our anti-fuzzing tool effectively neutralises potential threats before they can compromise the system. This capabil-
ity is crucial in a DevSecOps environment, where security must be both robust and seamless, ensuring that development processes are not disrupted [1].

The integration of these AI-driven tools into the DevSecOps framework not only enhances security but also aligns with the agile, fast-paced nature of modern software development. By automating key security functions, such as vulnerability detection, patching, and defence against fuzzing, we reduce the burden on developers and security teams. This allows them to focus on delivering secure, reliable software without sacrificing speed or innovation.

Looking forward, our efforts will continue to refine these AI models, particularly in handling complex scenarios and to expand the scope to cover a broader range of vulnerabilities and fuzzing techniques. We are also exploring collaborations with other ERCIM institutions to share insights and further develop these security tools, ensuring they remain at the cutting edge of technology. The work being done under the LAZARUS project represents a significant advancement in the way we approach software security within the DevSecOps framework. By embedding AI into every stage of the development process, we are not only enhancing security but also ensuring that it keeps pace with the rapid evolution of software technologies. As these tools continue to evolve, they will become essential components in the toolkit of any organisation committed to maintaining secure and resilient software systems in an increasingly complex digital landscape. For more details on our research and publications, visit the LAZARUS project website here [L1].

**Links:**

[L1] https://lazarus-he.eu

[L2] https://www.dynatrace.com/news/blog/what-is-devsecops

**References:**

[1] https://kwz.me/hDj

**Please contact:**

Qiang Tang, Luxembourg Institute of Science and Technology (LIST), Luxembourg, firstname.lastname@list.lu

# A Proposal for Privacy-preserving Ransomware Detection by means of Federated Machine Learning

by Giovanni Ciaramella (IMT School for Advanced Studies Lucca and CNR-IIT), Fabio Martinelli (CNR-IIT), and Francesco Mercaldo (University of Molise and CNR-IIT)

**The academic and industrial research community is exploring various machine learning methods to detect malware, particularly ransomware. However, real-world adoption is hindered by privacy concerns, as malware detection typically requires sending applications to a centralised model. To address this, we propose a privacy-preserving ransomware detection method using federated learning, which trains models locally on edge devices without transferring data. Preliminary experiments on a dataset of 15,000 real-world applications confirm the method's effectiveness.**

Over the years, the number of cyber-attacks has increased drastically. As shown in a report published by Statista, approximately 65% of financial organisations worldwide reported experiencing a ransomware attack in 2024, an increase from 64% in 2023 and 34% in 2021 [L1]. For many years, experts and researchers identified various solutions to protect users from attacks. Another issue in recent years is keeping personal data safe. To address that, the European Union introduced the General Data Protection Regulation (GDPR) in 2016 to regulate personal data usage. Nowadays, each technological device needs to handle personal data for several reasons. In 2017, to address the privacy issue, Google introduced the concept of federated machine learning [1]. This consists of training a model using local data, keeping raw data decentralised, and only sharing the model updated to the server.

In this article, we propose a method based on federated learning to classify malware, ransomware, and trusted applications

<figure><img src="image_21.png" /><figcaption>Figure 1: The Dirichlet distribution obtained among 15 different clients.</figcaption></figure>
<figure><img src="image_22.png" /><figcaption>Figure 2: The Confusion matrix.</figcaption></figure>

belonging to the Windows environment. We assessed the ef-
fectiveness of the proposed approach by exploiting over
15,000 samples divided into ransomware (5,000), generic mal-
ware (5,000), and trusted samples (5,000). The generic mal-
ware and ransomware samples were sourced from the
VirusShare repository [L2] while trusted samples were col-
lected from libraries (such as DLL files) and executable files
from a Microsoft Windows 10 machine. To verify the mali-
ciousness or trustworthiness of the samples, we submitted
them to the VirusTotal [L3] and Jotti [L4] web services. As the
next step, all executable files were transformed into text files
containing the opcodes obtained using the objdump disassem-
bler. To create an image representation, we assigned an RGB
value to each opcode within the file and used these values to
fill each matrix's pixel. Specifically, we assigned a distinct
colour to each opcode for all the applications involved in the
experimental analysis. After creating the complete dataset of
images, we divided it into training, validation, and testing sets
using an 80-10-10 split (12,000-1,500-1,500).

We started the experiment leveraging federated learning adopting the clipping norm aggregator, which limits the influence of individual data points by capping their gradients' norms before averaging them during model training, helping to reduce the impact of outliers. Moreover, in federated learning it is necessary to use a distribution because of the number of clients involved, and to recreate a real-world scenario we used non-IID data, i.e. Dirichlet distribution as shown in Figure 1. This type of distribution turns out to be different from the IID data [2] because it uses different statistical properties for each client, thus recreating a real-life scenario. After deciding on the norm type and distribution type to use, we began conducting experiments, employing a state-of-the-art architecture, i.e. MobileNetV3 [3]. To train our model, we used the "sgdm" optimiser, 15 clients, 20 rounds, and 15 epochs per round on each client. At the end of the experiments,

we obtained a model with an accuracy
value of 0.824 and a loss of 0.438 during
the test phase.

To evaluate the model's performance we computed the confusion matrix shown in Figure 2. The model was able to correctly identify 392 samples as “Trusted”, though it misclassified 108 instances, mistakenly labelling 9 as “Malware” and 99 as “Ransomware”. In the category named “Malware” the model achieved 435 correct predictions, with minor errors resulting in 13 instances being labelled as “Trusted” and 52 as “Ransomware”. The “Ransomware” category also performed strongly, with 390 accurate classifications. However, 110 samples were incorrectly categorised, with 60 samples classified as “Trusted” and 50 as “Malware”.

In conclusion, the federated learning ap-
plication in the malware detection field
can be crucial in enhancing detection ca-
pabilities by guaranteeing the respect of
user privacy. We demonstrated that a
model trained and tested by exploiting

federated learning can identify malware, ransomware, and
trusted Windows applications with interesting performance ac-
curacy. As future work, we plan to consider model explainabil-
ity with the aim to pinpoint which area of images related to ap-
plications are most distinctive for a given prediction.

This work has been partially supported by EU DUCA, EU CyberSecPro, SYNAPSE, PTR 22-24 P2.01 (Cybersecurity) and SERICS (PE00000014) under the MUR National Recovery and Resilience Plan funded by the EU - NextGenerationEU projects.

Links:

[L1] https://kwz.me/hDq

[L2] https://virusshare.com/

[L3] https://www.virustotal.com/

[L4] https://virusscan.jotti.org/

References:

[1] B. McMahan et al., “Communication-efficient learning of deep networks from decentralized data,” in Proc. of Artificial intelligence and statistics, pp. 1273–1282, PMLR, 2017.

[2] G. Ciaramella et al., “An approach for privacy-preserving mobile malware detection through federated machine learning,” in Proc. of 26th International Conference on Enterprise Information Systems, pp. 553–563, 2024.

[3] A. Howard et al., “Searching for mobilenetv3,” in Proc. of the IEEE/CVF International Conference on Computer Vision, pp. 1314–1324, 2019.

Please contact:

Giovanni Ciaramella, IMT School for Advanced Studies
Lucca, Italy and CNR-IIT, Pisa, Italy
giovanni.ciaramella@imtlucca.it and
giovanni.ciaramella@iit.cnr.it
# Vulnerability of Software Package Repositories: PyPI, Maven and rpm

by Daniel Setó-Rey, Carlos López-Nozal, and José Ignacio Santos-Martín (Universidad de Burgos)

The reuse of software by importing packages from repositories is an efficient way to develop software. However, reusing software in this manner introduces vulnerability risks due to transitive dependencies. These vulnerabilities must be measured to identify risks and propose corrective actions.

Software ecosystems are communities formed around programming languages and shared package management tools, enabling developers to create new packages that import and reuse the functionality of others [1].

Development within these ecosystems is efficient because common functionalities only need to be developed, maintained and tested by a single team, rather than having multiple authors reimplement the same functionality. The use of centralised library repositories to reduce development times and costs is widespread across nearly all languages and software projects. However, this efficient approach introduces vulnerability risks, primarily due to transitive dependencies and packages cycles. Because of dependency transitivity, a single defect in the repository can have far-reaching and unpredictable effects on the ecosystem. These defects may result in functional errors or issues with performance and security. The risk can be hard for developers to assess, as they typically import only a small portion of the dependencies.

In [2], we propose, develop, and test a new theoretical model to characterise the vulnerability of package repositories, which are represented as complex networks of dependencies. We define vulnerability as a metric that measures the sensitivity of a package repository to random defects represented by a cost function called φ Reach. We applied this model to three well-known package repositories (PyPI, Maven and rpm) to calculate their vulnerability [L1]. The package network and dependency information were constructed using the libraries.io data dump [L2]. Our analysis revealed that the emergence of a large strongly connected component (SCC), a set of

mutually dependent packages, is associated with a disproportionate increase in the vulnerability of package dependency networks (see details in Table 1).

Based on the concept of node vulnerability, we define immunisation at a node as any corrective or preventive action taken to eliminate the possibility of it failing or incorporating a defect. The effect of immunising a set of nodes is calculated as the difference between the network vulnerability of the initial network and that of the immunised network. In our experiments [2], we observed that protecting SCC to prevent the introduction or propagation of defects can nearly eliminate the network's vulnerability. However, depending on the number of such packages, this solution may not be practical. Identifying the optimal set of nodes to immunise for the greatest reduction in vulnerability is an NP-hard problem, so heuristics are necessary to find sufficiently good solutions. Figure 1 shows the SCC of the Maven package dependency network, consisting of 981 nodes (0.8% of the network). Immunising the component's cut vertices (351 nodes) can reduce vulnerability by

<table><caption>Table 1: Characteristics and vulnerability to failure of reference package dependency networks. n: number of packages, m: number of arcs (dependency relations), 2nd and 1st-SCC: second largest and largest strongly connected component present, φ Reach: vulnerability to failure measured by the Reach cost function and next to it percentage vulnerability in relation to network size (n).</caption><thead><tr><th></th><th>n</th><th>m</th><th>2<sup>nd</sup>-SCC</th><th>1<sup>st</sup>-SCC</th><th>φ Reach</th><th>φ Reach/n</th></tr></thead><tbody><tr><td>PyPI</td><td>50 766</td><td>155 369</td><td>4</td><td>14</td><td>15.73</td><td>0.0003</td></tr><tr><td>Maven</td><td>126 752</td><td>644 207</td><td>49</td><td>981</td><td>1805.54</td><td>0.0142</td></tr><tr><td>rpm</td><td>1 074 508</td><td>13 052 831</td><td>175</td><td>26486</td><td>27193.83</td><td>0.0253</td></tr></tbody></table>

<figure><img src="image_23.png" /><figcaption>Figure 1: The SCC of the Maven package dependency network consists of 981 nodes, representing 0.8% of the network. The nodes highlighted in white (351 nodes) are the component's cut vertices. The nodes highlighted in blue are the ten cut vertices with the highest out-degree centrality, while the nodes highlighted in red are the ten with the highest betweenness centrality.</figcaption></figure>
93.9%. Additionally, Figure 1 highlights the ten cut nodes with the highest out-degree centrality and betweenness centrality, resulting in vulnerability reductions of 13% and 26%, respectively.

We used a variety of techniques to narrow down the sets of important packages related to the network's vulnerability, achieving similar reductions by acting on a smaller number of packages. We demonstrate that selecting the set of strong articulation points (SAP) of the SCC achieves reductions similar to acting on the entire SCC.

This work helps decision-makers in software ecosystems (such as software developers, package developers and package repository managers) in assessing vulnerability risks caused by dependencies on third-party packages. Specifically, it can help:

* package repository managers to establish and follow vulnerability reduction plans

* software developers to evaluate the overall risk associated with the use of a given package

* package developers to assess the overall risk associated with package development in the context of a given repository

* package repository managers to establish measures to reduce or eliminate the occurrence of strongly related components, such as dependency cycle control

* package repository managers to implement immunisation policies to reduce the vulnerability of the network, with different techniques available to find good immunisation target sets.

**Links:**

[L1] https://doi.org/10.5281/zenodo.7358391

[L2] https://libraries.io/

**References:**

[1] C. Bogart, et al., "When and how to make breaking changes: policies and practices in 18 open source software ecosystems," ACM Trans. Softw. Eng. Methodol., vol. 30, no. 4, 2021. doi:10.1145/3447245

[2] D. Seto-Rey, J. I. Santos-Martin, and C. Lopez-Nozal, "Vulnerability of package dependency networks," IEEE Transactions on Network Science and Engineering, vol 10, no. 6, pp. 3396-3408, 2023. https://doi.org/10.1109/TNSE.2023.3260880

**Please contact:**

Carlos López-Nozal, Universidad de Burgos, Spain
clopezno@ubu.es

# Uninstallable by Design:
The Role of Pre-installed
Apps in Android's Security
Landscape

by Thomas Sutter (University of Bern and Zurich University of Applied Sciences), Ariane Trammell (Zurich University of Applied Sciences), and Timo Kehrer (University of Bern)

**The competitive smartphone market is keen to prevent its intellectual property from being analysed by competitors and the public. As a result, most smartphones are locked when distributed, and anti-reversing techniques are widely used. Consequently, millions of users use smartphones daily without a clear understanding of the software's functionality and purpose. We developed a novel framework, FirmwareDroid, to analyse the security of mobile device firmware.**

Nowadays, most smartphones come with a large number of pre-installed mobile apps. For instance, on Android, it is normal to find between 150 and 1,000 pre-installed apps for various purposes. Some of these apps are essential for the system to operate correctly, while others aim solely to enhance the user experience. Android allows the inclusion of third-party apps. Thus, many devices come shipped with apps that some users don't want or need on their devices, such as social media and news apps. These apps are often referred to as "bloatware," as they unnecessarily bloat the device's operating system and cannot be simply uninstalled by users. The main reason why bloatware on Android cannot be uninstalled is a security feature that prevents attackers from modifying system apps on the device.

On Android, the file system where pre-installed apps are stored is read-only, to prevent any modifications to the system. This security feature is fundamental and complements other security mechanisms (e.g. Android Verified Boot) to prevent Man-At-The-End (MATE) attacks. As most Android devices are effectively locked, users cannot remove pre-installed apps from the filesystem without unlocking the bootloader of the device (e.g. by rooting or jailbreaking).

Moreover, the open-source nature of Android allows vendors to modify existing system apps by adding or removing functions. As these modifications are mainly closed-source changes, they might introduce bugs that affect the security of the device. Recent studies have found several security issues in pre-installed apps [1] and identified privacy concerns [2] but could only provide limited insights in terms of analysis methods applied. This demonstrates the need for better testing and verification of pre-installed apps on mobile devices.

Undoubtedly, there is a high level of public interest in knowing what data is collected on smartphones and which vendors follow good software development and security practices. As a result, in an attempt to restore some transparency, we developed a framework called FirmwareDroid [L1] that allows the
<figure><img src="image_24.png" /><figcaption>Figure 1: Smartphones are distributed with hundreds of pre-installed apps that cannot be uninstalled by users, but are these apps secure?</figcaption></figure>

extraction of pre-installed apps from Android firmware. FirmwareDroid's purpose is to automate the security analysis of pre-installed apps for various purposes, such as detecting vulnerabilities, identifying malware, or privacy issues. In addition, the project makes the analysis more applicable for practitioners and allows researchers to integrate their own testing tools.

With FirmwareDroid, we demonstrated that many pre-installed apps utilise advertising trackers and have a concerning number of dangerous privileges [3]. Currently, FirmwareDroid includes several state-of-the-art static analysis tools, and the framework allows for the extraction and analysis of apps at scale with its multi-core scanning engine. However, the dynamic analysis of pre-installed apps has not been well studied and primarily relies on physical devices for testing, which is cost-intensive, does not scale well, and is challenging due to vendors implementing anti-reversing techniques.

As we continue to improve FirmwareDroid, our next critical objective is to expand its capabilities to include dynamic analysis of pre-installed apps. This enhancement will significantly strengthen the tools available to researchers, enabling them to conduct more comprehensive and detailed studies.

Given the highly fragmented nature of Android, each vendor's custom modifications to the operating system present unique challenges. To address this, we recognise the need for innovative solutions that allow us to test these modifications in real time. Understanding what changes have been made and the reasons behind them is not only valuable for advancing research but also essential for safeguarding the public's digital security.

To achieve this, we are developing a solution that facilitates the dynamic testing of Android pre-installed apps without the need for physical devices. By leveraging advanced emulation technologies, we aim to create a scalable, cost-effective method for analysing these apps in a controlled environment. This development will open new avenues for research and provide greater transparency, ultimately contributing to a safer and more secure mobile ecosystem for everyone. Through this project, we hope to help both the research community and the public regain some transparency and further strengthen the security of mobile devices.

FirmwareDroid is open-source and will be continuously developed over the coming years. Contributions to the framework or our research are welcome.

**Link:**

[L1] https://github.com/FirmwareDroid/FirmwareDroid

**References:**

[1] M. Elsabagh, et al., “FIRMSCOPE: automatic uncovering of privilege-escalation vulnerabilities in pre-installed apps in Android firmware,” in USENIX, 2020.

[2] J. Gamba, et al., “An analysis of pre-installed android software,” in IEEE S&P, 2020.

[3] T. Sutter and B. Tellenbach, “IEEE/ACM MOBILESoft,” in *FirmwareDroid: Towards Automated Static Analysis of Pre-Installed Android Apps*, 2023.

**Please contact:**

Thomas Sutter, PhD Student Software Engineering Group,
University of Bern, Switzerland
thomas.sutter@unibe.ch

Ariane Trammell, Head of Information Security Group,
Zurich University of Applied Science, Switzerland
ariane.trammell@zhaw.ch
# Towards Cyber Security Risk Analysis for Digital Products

by Christophe Ponsard and Jean-François Daune (CETIC)

Digital products have become ubiquitous across all domains for everyday activities of both citizens and companies. Providing secure products is required to ensure the organisations relying on them have a minimal attack surface. This article highlights specific needs and our ongoing work to conduct a cyber security risk analysis for a digital product, which is also increasingly required by regulations such as the EU The Network and Information Security Directive (NIS2) or the upcoming Cyber Resilience Act.

Conducting regular cyber security risk analysis inside an organisation is strongly recommended to stay resilient against a quickly evolving threat landscape. It is a mandatory step in many standards and related certifications across many sectors such as ISO27002 (Information Technology - IT), IEC 62443 (Operational Technology - OT) and SAE 21434 (automotive). Those approaches are however performed at a full organisation level and do not focus on the point of view of the editor providing a digital solution. However, securing the supply chain is now part of regulations such as the NIS2 and specific security requirements will also apply to digital products with the upcoming Cyber Resilience Act (CRA).

When investigating available methods for conducting a risk analysis targeting a digital product, two main limitations emerged. First, many methods are focusing on protecting the organisation's business assets through a large set of supporting IT assets. These methods do not take the point of view of a digital product, although they identify potential threats related to their configuration, (mis)use, update and, more recently, development. This typically relies on the ISO27005 iterative risk-oriented approach with methods such as EBIOS (France)

[L1], IT-SRM (EU) [L2] or MONARC (Luxembourg) [L3] that we investigated and were also reviewed by ENISA [1]. Second, product-oriented methods focus more on checking the implementation with respect to the security specification by examining the security maturity across the lifecycle and (pen) testing the product (e.g. assurance levels in the common criteria). However, they just assume a prior risk assessment to show the security objectives are addressing identified threats. Those methods can also be cumbersome and have difficulties coping with product evolution, although more incremental processes are being investigated [2].

A product-oriented risk analysis requires a mix of approaches with the product as central asset. It must deal with different aspects such as the interaction with the outer ecosystem, the security guarantee to provide on specific information/processes (including the product itself in integrity and for intellectual property), the inner product architecture, the resulting attack surface through its interfaces, the internal development process and the product dependencies (e.g. through Software Bill of Materials). Additional requirements are to rely as much as possible on available methods and tools in order to be efficient and to stay compliant with existing standards. An architecture modelling foundation also enables a precise description, in-depth analysis (e.g. using recommended threat modeling) and automation for generating artefacts or identifying security measures.

After an in-depth review of the methods mentioned above, we decided to adopt IT-SRM as our core method for several reasons. First, as IT systems are our main focus, it is 27001 compliant but it can also be considered as the basis for specialised domains such as OT or medical software. Second, it is very well documented including catalogues borrowed from other methods such as EBIOS. Finally, it quite systematically supports the review of the required security properties over technical assets to produce risk estimates and, from there, to decide about additional security measures. The method does not provide tool support but can easily be automated using spreadsheets and modelling tools as depicted in Figure 1, which is freely inspired by a real case study.

<table><caption>Figure 1: Current ISRM tool support with spreadsheet (right) and Threagile architecture modelling (left).</caption><thead><tr><th>#</th><th>Risk</th><th>Asset</th><th>CIA</th><th>Impact</th><th>Freq</th><th>Ease</th><th>Pow</th><th>Mot.</th><th>Level</th><th>Risk</th><th>Start</th><th>Res.</th><th>Risk</th></tr></thead><tbody><tr><td>R1</td><td>Malicious doctor extr...</td><td>Patient data</td><td>C</td><td>1</td><td></td><td>2</td><td>5</td><td>3</td><td>3</td><td>Accept</td><td>3</td><td></td><td></td></tr><tr><td>R2</td><td>Adversary modifying ...</td><td>Patient data</td><td>I</td><td>8</td><td></td><td>2</td><td>5</td><td>3</td><td>27</td><td>Red</td><td>6</td><td></td><td></td></tr><tr><td>R3</td><td>Adversary installing ...</td><td>Patient data</td><td>I</td><td>8</td><td></td><td>2</td><td>5</td><td>3</td><td>27</td><td>Red</td><td>6</td><td></td><td></td></tr><tr><td>R4</td><td>Admin IT configuring ...</td><td>Patient data</td><td>I</td><td>8</td><td>3</td><td></td><td></td><td></td><td>24</td><td>Red</td><td>7</td><td></td><td></td></tr><tr><td>R5</td><td>Adversary installing ....</td><td>Patient data</td><td>I</td><td>8</td><td></td><td>2</td><td>5</td><td>3</td><td>27</td><td>Red</td><td>2</td><td></td><td></td></tr><tr><td>R6</td><td>Adversary faking OM...</td><td>Patient data</td><td>A</td><td>8</td><td>2</td><td></td><td></td><td></td><td>16</td><td>Red</td><td>13</td><td></td><td></td></tr><tr><td>R7</td><td>Web server stop func...</td><td>Patient data</td><td>A</td><td>8</td><td>3</td><td></td><td></td><td></td><td>24</td><td>Red</td><td>12</td><td></td><td></td></tr><tr><td>R8</td><td>Database stops funct...</td><td>Patient data</td><td>A</td><td>8</td><td>3</td><td></td><td></td><td></td><td>24</td><td>Red</td><td>14</td><td></td><td></td></tr><tr><td>R9</td><td>Adversary eavesdrop...</td><td>Patient data</td><td>C</td><td>1</td><td></td><td>3</td><td>5</td><td>3</td><td>4</td><td>Red</td><td>2</td><td></td><td></td></tr><tr><td>R10</td><td>Adversary altering d...</td><td>Patient data</td><td>I</td><td>8</td><td></td><td>2</td><td>5</td><td>3</td><td>27</td><td>Red</td><td>14</td><td></td><td></td></tr><tr><td>R11</td><td>Adversary preventing ..</td><td>Patient data</td><td>A</td><td>8</td><td></td><td>3</td><td>5</td><td>3</td><td>29</td><td>Red</td><td>11</td><td></td><td></td></tr><tr><td>R12</td><td>Adversary installing ....</td><td>Patient data</td><td>C</td><td>1</td><td></td><td>3</td><td>5</td><td>3</td><td>4</td><td>Red</td><td>2</td><td></td><td></td></tr><tr><td>R13</td><td>Adversary installing ...</td><td>Patient data</td><td>I</td><td>8</td><td></td><td>3</td><td>5</td><td>3</td><td>29</td><td>Red</td><td>1</td><td></td><td></td></tr><tr><td>R14</td><td>Adversary installing ....</td><td>Patient data</td><td>I</td><td>8</td><td></td><td>3</td><td>5</td><td>3</td><td>29</td><td>Red</td><td>8</td><td></td><td></td></tr><tr><td>R15</td><td>Adversary gaining ac...</td><td>Patient data</td><td>I</td><td>8</td><td></td><td>3</td><td>5</td><td>3</td><td>29</td><td>Red</td><td>1</td><td></td><td></td></tr><tr><td>R16</td><td>Adversary DDoS atta...</td><td>Patient data</td><td>A</td><td>8</td><td></td><td>4</td><td>5</td><td>3</td><td>32</td><td>Red</td><td>12</td><td></td><td></td></tr><tr><td>R17</td><td>Adversary sqlInjection...</td><td>Patient data</td><td>A</td><td>12</td><td></td><td>3</td><td>5</td><td>3</td><td>44</td><td>Red</td><td>12</td><td></td><td></td></tr><tr><td>R18</td><td>Adversary corrupting...</td><td>Patient data</td><td>A</td><td>12</td><td></td><td>3</td><td>5</td><td>3</td><td>44</td><td>Red</td><td>9</td><td></td><td></td></tr></tbody></table>

<figure><img src="image_25.png" /></figure>
The next step of our work is to improve tool support to better capture the product architecture and guide the analysis, e.g. inside the Open Source MONARC risk analysis tool based on our previous work [3]. For this, we are also investigating how to enrich the component classification, related risks and countermeasures. Finally, our work is currently being validated on different use cases, e.g. a medical ERP [L4], in the scope of a grand challenge on risk analysis for penetration testing proposed by the Belgian CyberWal platform and driven by industrial needs.

**Links:**

[L1] https://kwz.me/hDw

[L2] https://kwz.me/hDx

[L3] https://www.monarc.lu

[L4] https://kwz.me/hDz

**References:**

[1] C. Lambrinoudakis et al, "Interoperable EU risk management framework," ENISA Report, 2022.

[2] S. Dupont et al, "Product incremental security risk assessment using DevSecOps practices," SecAssure@ESORICS 2022.

[3] C. Ponsard et al, "Improving cyber security risk assessment by combined use of i* and infrastructure models," IStar conference, 2021.

**Please contact:**

Christophe Ponsard, CETIC, Belgium

christophe.ponsard@cetic.be

# Challenges for the Secure Integration of Drones into Warehouse Logistics of SMEs

by Peter Kieseberg (St. Pölten UAS), Christoph Kaltenriner (Dataphone GmbH), and Peter Gallistl (Dataphone GmbH)

Drones promise significant benefits for small-and-medium-sized enterprises (SMEs) in warehouse logistics, but integrating them securely into existing systems is a complex challenge. This article explores how SMEs can overcome security risks - including man-at-the-end (MATE) attacks - and operational hurdles to effectively adopt drone technology.

Drones offer a lot of benefits when used for mundane tasks in warehouses, especially with respect to inventorisation. Thus, companies running large warehouses have dived deep into automatisation, optimising their warehouses accordingly with specially designed solutions. This not only includes the integration of robotic hardware, be it ground-based solutions or even drones, but especially rebuilding the warehouse with intelligent shelving systems that communicate with the infrastructure and potentially the mechanical actors. Security is very important in these solutions [1], with a lot of thought put into the respective aspects of the system architecture, includ-

ing focus on MATE attacks. While these solutions are certainly very promising for large cooperations being able to build large custom-made warehouses, it is infeasible for the standard SME, both, from a cost side, as well as from the fact that SMEs typically cannot shut down their facilities for long in order to update them to this level.

Thus, intelligent warehouse logistics using drones needs to be able to securely integrate with a lot of legacy equipment, ranging from the very shelves to the software components controlling the warehouse, in order to allow for secure integration. This especially poses problems for current state-of-the-art drone solutions, as these environments are not able to support the drones through communication and shelf-side automation features. Furthermore, the high degree of automation as is pushed forward by big cooperations is not feasible for SMEs, still requiring human workers to fulfil a multitude of tasks. This further complicates the task of drone integration, as human workers might leave goods on the floor, or might not stack shelves exactly enough in order for the drones to follow their flight paths without bumping into them. While this could theoretically be solved using AI methods, recent research has shown that drones have severe problems in similar complex environments [2].

Given the side parameters outlined above, security becomes a major concern, especially considering MATE attacks when comparing the environments to highly professional automated logistic warehouses:

1. The drone control system needs to interact with a multitude of different backend software systems, often of questionable security.

2. Configuration of and interaction with the system needs to be done on a regular basis by a lot of involved persons due to layout changes in the warehouses and the absence of communication with the shelving systems. This stands in stark contrast to modern warehouses of large companies that are

<figure><img src="image_26.png" /><figcaption>Illustration of a drone in a warehouse.</figcaption></figure>
highly optimised for automation.

3. In addition, the typical shelving system prevailing in SMEs has no means of detecting mis-stacking or other errors in the stacking process, thus requiring the drone and its control system to take care of such matters. This adds a layer of complexity that is either ignored and put into the hands of the human workers, or can cause problems for the drones, e.g. through crates invading the drones' designated flight paths. Drones with the necessary sensors on board for dealing with these kinds of problems are currently prohibitively expensive for most SMEs.

4. In addition, warehouses in the SME sector are in general not fully automated, i.e. human workers need to work there too. While side-by-side work with drones is currently out of the question in this price class for safety reasons, so-called mixed environments can be set up by separating the drones from the human workers through shifts, e.g. having the human workers work by day and the drones doing their tasks like inventorisation at night. This, of course, also opens a lot of chances of interference of workers with the drones, either due to carelessness or malicious intent.

In addition, contrary to many other environments, small disturbances can wreak havoc on a company, especially when dealing with Just-in-Time (JIT) logistics. Another MATE-related problem lies in the fact that both logistics software, as well as software controlling the drones, are typically closed source. While the former is often quite old and undocumented, current developments in AI also allow drone control software to evolve very quickly, which makes security testing complex and costly. Furthermore, procurement of systems containing AI components is far from trivial from a security perspective, as shown in [3]. While typical logistics does not fall under the high-risk level of the AI-Act, except of course where critical infrastructure is involved, they might need to follow the NIS and NIS2 regulations, where a lot of legal work needs to be done with respect to training of AI systems and AI risk management.

In summary, drones in SME warehouses offer great opportunities in becoming more competitive and cutting costs for many tasks like inventorisation, yet there are still open challenges with respect to system hardening, especially against MATE attacks.

**References:**

[1] A. Rejeb, et al., “Drones for supply chain management and logistics: a review and research agenda,” Int. J. of Logistics Research and Applications, pp.1–24, 2021.

[2] A. Buchelt, et al., “Exploring artificial intelligence for applications of drones in forest ecology and management,” Forest Ecology and Management, vol. 551, p.121530, 2024.

[3] P. Kieseberg, et al., “Security considerations for the procurement and acquisition of Artificial Intelligence (AI) systems,” in 2022 IEEE Int. Conf. on Fuzzy Systems (FUZZ-IEEE), pp. 1–7.

**Please contact:**

Peter Kieseberg, St. Pölten University of Applied Sciences,
Austria
peter.kieseberg@fhstp.ac.at

# Enhancing IoT Security Across the Supply Chain

by Ramon Barakat, Sascha Hackel (Fraunhofer FOKUS) and Miltiadis Siavvas (CERTH)

**The Design and Operation of Secure Supply Chain (DOSS project's Supply Trust Chain idea seeks to truly improve IoT security and trust from design to deployment. The project's goal is to secure the IoT supply chain throughout its lifecycle, ensuring that stakeholders always have access to security-related information.**

The DOSS project [L1], under the Horizon Europe initiative, is dedicated to securing the IoT supply chain throughout its entire lifecycle. This project aims to ensure IoT security by monitoring all stages from design to decommissioning, making security-relevant information accessible to stakeholders, and fostering robust communication among various actors.

The Device Security Passport, a machine-processable document that contains pertinent security data for IoT components, such as certificates, SBOM, HBOM, and MUD files, is one of the essential parts of the DOSS project. This document will be stored in a secure, accessible repository, ensuring that security data is both reliable and protected.

Figure 1 illustrates the preliminary architecture of the DOSS project, highlighting the integration of various modules and workflows. This architecture outlines how different components, such as the Component Tester and the Digital Security Twin, interact to ensure comprehensive security validation. By detailing these interactions, Figure 1 provides an overview of the system's design and operational flow, emphasising the project's holistic approach to IoT security.

**Component Tester and Vulnerability Prediction**

Adopting the Zero Trust principle of “never trust, always verify,” DOSS will validate all IoT architecture components at multiple stages. A unified Component Tester will verify the Device Security Passport’s content and ensure the security of the IoT components.

The Component Tester will ensure the security of the IoT components including third-party applications (closed- and open-source software) and proprietary developments. It utilises a comprehensive testing and validation methodology, analysing closed-source software using binary code validation techniques and verifying components according to their Device Security Passports. Software security verification methods will be used to evaluate open-source software and proprietary development.

The DOSS project emphasises the importance of Interactive Application Security Testing (IAST) to address the complexities of IoT security. IAST combines the strengths of Static Application Security Testing (SAST) and Dynamic Application Security Testing (DAST) to provide a more comprehensive security analysis.

In addition to the static analysis, a Vulnerability Prediction module using Large Language Models (LLMs) will be inte-
<figure><img src="image_27.png" /><figcaption>Figure 1: Overview of the supply chain integration (Supply Trust Chain).</figcaption></figure>

grated. The vulnerability prediction focuses on identifying se-
curity hotspots in software components, enabling better alloca-
tion of testing resources [2]. DOSS will explore the use of
popular pre-trained LLMs for vulnerability prediction, includ-
ing Generative Pre-trained Transformer (GPT), Bidirectional
Encoder Representations from Transformers (BERT), and
Bidirectional Auto-Regressive Transformers (BART), which
will be fine-tuned using curated vulnerability datasets and
compared against traditional text-mining-based models. For
enhancing their accuracy, additional modalities will be used as
inputs to capture more context from the source code, focusing
on text-rich graphs, such as Abstract Syntax Trees (ASTs),
Control-flow Diagrams (CFDs), etc. Explainable AI (XAI)
techniques will be also leveraged to facilitate vulnerability lo-
calisation [3].

An essential aspect of the DOSS CT is the patch validation
process. Directed fuzzing techniques are used to ensure that
security patches effectively fix vulnerabilities completely
without introducing new ones. This technique generates a suite
of tests that trigger the identified vulnerabilities in various
ways during patch development, ensuring comprehensive cov-
erage and validation. This integrated approach enhances the
detection of vulnerabilities and streamlines the remediation
process, ensuring that only secure components are integrated
into the IoT architecture.

IoT Operation and Supply Trust Chain

DOSS extends its security concept to IoT operation. New de-
vices will be integrated using an automated Onboarding
Platform, leveraging the Device Security Passport for config-
uration. Furthermore, the CT of the DOSS project is designed
to be versatile, allowing for use not only during the develop-
ment phase but also on the operator side. This ensures ongoing
security validation.

Infrastructure automation technologies will be used to model
various service architectures by importing verified components
into a Digital Cybersecurity Twin. High-level system descrip-
tions will be extracted by AI-assisted models to detect threats
and suggest defences. The Architecture Security Validator will
perform automated architecture validation on these models en-
suring also their compliance with industry standards. The

tested, modelled, and validated IoT architectures will also be
monitored during their operation by the IoTAC platform pre-
sented in [1]. The IoTAC platform [L2] will monitor and pro-
tect the operational environment, providing feedback to design-
time modules and stakeholders through the Supply Trust Chain.

Conclusion

The DOSS project aims to significantly enhance the security
and trust of IoT services and architectures. Through its com-
prehensive approach, DOSS strives to contribute to a more se-
cure and trustworthy IoT ecosystem. The project's findings
will be validated in automotive, prosumer cell operation, and
smart home domains, ensuring practical relevance and impact.

The DOSS project has received funding from the European
Union's Horizon Europe research and innovation programme
under grant agreement No 101120270.

Links:

[L1] https://dossproject.eu

[L2] https://iotac.eu/

References:

[1] S. Hackel, M. Schneider, and R. Barakat, “Security-by-design IoT development and certification with IoTAC,” ERCIM News 134, Jun. 2023. https://ercim-news.ercim.eu/en134/r-i/security-by-design-iot-development-and-certification-with-iotac

[2] I. Kalouptsoglou, et al., “Software vulnerability prediction: A systematic mapping study,” Information and Software Technology, vol. 107303, 2023.

[3] M. Fu and C. Tantithamthavorn, “Linevul: A transformer-based line-level vulnerability prediction,” in Proc. of the 19th Int. Conf. on Mining Software Repositories, 2022, pp. 608–620.

Please contact:

Ramon Barakat, Fraunhofer FOKUS, Germany
ramon.barakat@fokus.fraunhofer.de

Sascha Hackel, Fraunhofer FOKUS, Germany
sascha.hackel@fokus.fraunhofer.de
# Towards Safer Software:
Exploring Validation
Techniques for Rust
Binaries

by Antonis Louka (University of Cyprus), Andreas Dionysiou (Frederick University), and Elias Athanasopoulos (University of Cyprus)

> In today's programming landscape, ensuring software security is more critical than ever. Rust, a relatively new programming language, incorporates safety features that produce secure and efficient machine code without relying on runtime support. In our work, developed at the University of Cyprus, we explore how an attacker might deliberately create vulnerabilities in Rust binaries post-compilation, and the need for code validation for such systems.

Current programming systems can be split into safe and unsafe based on how they manage memory. Traditional (unsafe) systems like C/C++ are built using a loose memory management model that depends on the programmer to manage memory. Safe systems on the other hand, such as Java and C#, use heavy runtime support to perform memory management accounting and ensure safety. Rust, a new programming language, enforces memory safety without runtime support, providing a new middle ground between the two aforementioned categories. Other similar efforts are Go, which depends on a lightweight garbage collector, and Swift, which uses automatic reference counting.

Specifically, Rust uses the Ownership, Borrowing, and Lifetime concepts to create Rust-specific rules to automate memory management and avoid temporal-safety bugs like

use-after-free (UaF) or double free (DF) bugs. Such rules are enforced by a Rust compiler routine called the “Borrow Checker”. Additionally, Rust adds automatic checks in the program that are essentially conditional statements during compilation for avoiding spatial-safety bugs, such as buffer overflows (BO). Overall, Rust's safety measures are enforced during compilation, leaving the binary without any guarantees during execution other than trusting the compiler's output. These measures can be also bypassed using the unsafe keyword that is mainly used to integrate C code in Rust programs.

In our work, we argue that the machine code produced by a Rust compiler should be validated for safety before reaching the end user. Such a validation process is not new, but has been applied in the past when web browsers supported running third-party native code using the NaCl framework [1]. More precisely, we argue that when a binary is submitted to an app store, there should be a validating routine along with code-reviewing mechanisms that assess if the given binary adheres to memory-safety Rust-specific rules.

We demonstrate that an attacker can stealthily modify a Rust binary and recreate temporal and spatial safety bugs. The machine code produced by the Rust compiler can later be altered to introduce such bugs into the binary that reaches the end user. This provides an opportunity for malicious developers to compile an application and stealthily add malicious bugs for later exploitation (see Figure 1).

This is a similar scenario to that depicted by Wang et al. [2], and the creation of Jekyll apps (intentionally malicious applications that bypass the defence mechanisms of the IOS store). In this case (i) the compiler cannot be trusted to be the only entity that ensures memory safety for such systems, (ii) the digital signature measures cannot detect if the application has been tampered with or not since the developer is the actual attacker, and (iii) current review mechanisms cannot capture such alterations as they do not follow Rust's memory safety rules. The

<figure><img src="image_28.png" /><figcaption>Figure 1: Threat model diagram: A malicious developer creates a benign Rust application that successfully passes the compilation phase. The developer then uses a modification process that alters the binary and creates a bug i.e. BO, UaF making the binary vulnerable. Finally, the developer publishes the vulnerable binary to an application store that does not utilise language-specific validation, bypassing the different reviewing mechanisms. After multiple users download and install the malicious application, the developer can exploit the vulnerable binaries remotely.</figcaption></figure>
aforementioned reasons mandate the creation of validation
routines that check specific artifacts in an executable that are
language-specific and fundamental to enforce memory safety.

The validation methodology proposed in this work focuses on
Rust binaries only, and during our experiments, we demon-
strate that certain Rust safety measures, such as checks for
BOs, can be more easily manipulated, while others, such as
Uaf, need more elaborate modifications. We demonstrate that
by stealthily changing the conditional statements added by the
compiler, traditional BOs can be created and used to corrupt
stack control data, i.e. return addresses. We additionally show
that fundamental Rust rules enforced by the Borrow Checker
can be bypassed to create dangling pointers and Uaf bugs.

We develop a preliminary validation framework that uses heuristics and other specific patterns of Rust, i.e. exception-handling patterns and buffer initialisation patterns, and we focus on the validation of buffer-overflow checks and buffer references. Our framework validates buffer-overflow checks by comparing them with a ground truth conditional check (created from analysing the binary). For reference validation, we use data-flow tracking from a given buffer (source) to other aliases (references) while simulating Rust's rules and checking for any violations.

The ability to validate code for such programming systems is
crucial not only for scenarios as described in this article. Rust
and Go are currently very popular and attractive choices for
creating system applications. Many developers have started
migrating code from C/C++ to Rust to benefit from memory-
safety guarantees. Validating such code is also not trivial as
unsafe blocks of code need to be handled differently than reg-
ular safe code. This information is not present in a compiled
binary, which creates the need to add validation symbols in an
executable to assist future validation frameworks. On the other
hand, some work has demonstrated that concepts used to auto-
mate memory allocation and deallocation may produce bugs,
especially when interacting with unsafe Rust code [3].
Validation frameworks may be able to capture such bugs be-
fore the application reaches the end user.

Our research introduces an initial validation approach specifi-
cally targeting Rust buffers in binaries; however, much work
remains to develop a comprehensive validation framework for
the new era of programming systems such as Rust.

References:

[1] B. Yee et al., “Native client: a sandbox for portable, untrusted x86 native code,” in 30th IEEE Symposium on Security and Privacy, 2009, pp. 79–93.

[2] T. Wang, et al., “Jekyll on iOS: when benign apps become evil,” in 22nd USENIX Security Symposium (USENIX Security 13), 2013, pp. 559–572.

[3] M. Cui and Y. Zhou, “SafeDrop: Detecting memory deallocation bugs of rust programs via static data-flow analysis,” ACM Transactions on Software Engineering and Methodology, vol. 32, no. 4, pp. 1–21, 2023.

Please contact:

Elias Athanasopoulos, University of Cyprus
athanasopoulos.elias@ucy.ac.cy

The Salto Project: Static
Analysis of OCaml
Programs by Abstract
Interpretation

by Pierre Lermusiaux and Benoît Montagu (Inria)

Functional programming languages, such as OCaml, take
advantage of strong static guarantees provided by their
type checkers that ensure that well-typed programs cannot
“go wrong”. However many correctness and safety proper-
ties escape the scope of the guarantees provided by the
type system. In order to provide some additional guaran-
tees, the Salto project leverages static analysis techniques,
mainly based on abstract interpretation, to develop tools
that help OCaml programmers increase the confidence in
their programs.

With the wide-spread use of cyber-systems, the programs con-
trolling these systems have become the keepers of our personal
data. Malfunctioning programs expose all these systems to at-
tacks and faults that can put our data and our lives at risk.
Thus, the questions of safety and correctness of the programs
and protocols used in critical systems are now essential issues
for the future of information technologies. Providing formal
guarantees on the behaviour of programs is, however, a chal-
lenging problem that often requires advanced scientific knowl-
edge, which limits the adoption of software analysis tools in
industry.

While dynamic techniques based on tests and simulations have
been preferred so far in industry, the adoption of abstract-inter-
pretation-based tools, such as Astrée [1], a static analyser for
C programs, have proven the interest and applicability of static
and formal analysis techniques. Recently, NomadicLabs [L3]
has shown interest in using software analysis tools to improve
the confidence on the large OCaml code base behind the Tezos
crypto-currency. This prompted a collaboration between
NomadicLabs and Inria to fund the Salto project [L1] that of-
ficially started in November 2022.

OCaml [L2] is a functional programming language with auto-
matic memory management, which is developed and main-
tained by Inria researchers. It's strong type system guarantees
that a well-typed OCaml programs are memory safe, i.e. that
data is used in a consistent way by the program. However, po-
tential errors, such as mishandled exceptions, arithmetic over-
flow, out-of-bound accesses, and the detection of undefined
behaviours escape the scope of these guarantees. The goal of
the Salto project is to define sound static analysis techniques
to formally detect such cases.

The formal verification of non-trivial properties of a program
is a notoriously undecidable problem, meaning that there is no
general method able to systematically prove or disprove se-
mantics properties of a program. To circumvent this formal
limitation of static analyses, the abstract interpretation frame-
work proposes to compute an over-approximation of a pro-
gram's reachable states. An abstract interpreter can do so effi-
<figure><img src="image_29.png" /><figcaption>Figure 1: Representation of three possible analysis results.</figcaption></figure>

ciently by relying on the notion of abstract domains that define over-approximations of the sets of possible states of a program, called abstract values, and the abstractions of the semantic operations of a program on these abstract values.

This approach allows abstract interpreters, like Astrée and Salto, to accurately detect all executions that might contradict the desired semantic properties (i.e. the analysis is sound), while sometimes raising false alarms about executions that cannot happen in reality (see Figure 1). The goal of an abstract interpreter is therefore to be as precise as possible to minimise the number of false alarms, while being efficient enough to analyse programs in a reasonable time. In the context of functional languages such as OCaml, applying the abstract interpretation framework is particularly challenging, because data flow and control flow are interdependent: the control flow of programs is dynamically derived from the application of functional terms, whose values generally depend on all evaluations performed before. While other work [3] has relied on techniques such as inference of types and effects to statically analyse OCaml programs, our work on Salto constitutes one of the first efforts to propose a wide-scale analysis of OCaml programs based on abstract interpretation.

To define and implement this static analyser, the Salto project has led to the definition of an intermediate language, where redundant features of the OCaml language are conflated, and disambiguation of pattern-matching is performed. This intermediate language simplifies both the definition of the semantics of programs, and the implementation of our abstract interpreter. The abstract interpreter relies on a novel abstract domain that can represent recursively defined sets of values, including function closures. This abstract domain features a dual representation of abstract values, that can be viewed both as tree terms, which can be hash-consed and memoised to ensure the analysis performance, as well as graphs, in order to implement tree-automaton-inspired operations on the set of values they represent.

The Salto project has reached a first milestone with the implementation of a static analyser for OCaml programs, parameterised over the abstract domains of OCaml primitive datatypes, that can detect uncaught exceptions accurately [2], and arithmetical errors, such as integer overflow. This analyser has been tested on a large test suite, and already supports a large subset of features of OCaml, including dynamically extensible data-types, mutable records, and the module system. The sup-

port in Salto of more advanced OCaml features is under active development (such as recursive non-functional terms and modules), that will permit to analyse the Tezos code base ultimately. Finally, we believe that the Salto abstract interpreter constitutes a solid basis to experiment with analyses that detect more advanced security issues in OCaml programs, such as undesirable side effects, resource leaks, or cases where the behaviour of a program may depend on the evaluation order chosen by the compiler.

**Links:**

[L1] Salto: https://salto.gitlabpages.inria.fr

[L2] OCaml: https://ocaml.org

[L3] NomadicLabs: https://www.nomadic-labs.com

**References:**

[1] P. Cousot et al: "The ASTREÉ Analyzer," ESOP 2005.

[2] P. Lermusiaux and B. Montagu, "Detection of uncaught exceptions in functional programs by abstract interpretation," ESOP 2024.

[3] X. Leroy and F. Pessaux, "Type-based analysis of uncaught exceptions," ACM TOPLAS, vol. 22 Issue 2, March 2000.

**Please contact:**

Pierre Lermusiaux, Inria, France
pierre.lermusiaux@inria.fr

Benoît Montagu, Inria, France
benoit.montagu@inria.fr
# Generating Mixed Boolean-Arithmetic Expressions through Equality Saturation

by Caroline Lawitschka and Sebastian Schrittwieser
(University of Vienna)

**We introduce a novel methodology for generating complex and robust Mixed Boolean-Arithmetic (MBA) expressions for various software protection methodologies. Our research specifically focuses on leveraging the concept of equality saturation to create MBA expressions of arbitrary complexity.**

Mixed Boolean-Arithmetic (MBA) expressions combine Boolean logic operations such as AND, OR, XOR, and NOT with arithmetic operations like addition (+), subtraction (-), multiplication (*), and division (/). This combination provides a powerful tool for creating complex expressions that can be used in code obfuscation.

Code obfuscation is a broad term encompassing techniques used to make program code more difficult to understand, analyse, and reverse-engineer, thereby protecting intellectual property and preventing software tampering. In the software protection domain, MBA expressions are often used to generate opaque predicates, which always evaluate to either true or false, independently from their inputs. While the software developer knows the evaluation result of the opaque predicate, it is time-consuming for an attacker to figure out its input-independence and the correct evaluation result. In practice, opaque predicates help create fake branches with paths that are never executed at runtime. The effectiveness of MBA in obfuscation techniques has been well-documented in the literature. For instance, Zhou et al. [1] demonstrated how MBA expressions can be utilised for information hiding in software, highlighting

the robustness of MBA-based obfuscation methods against various analysis techniques.

However, MBA-based obfuscations are not invincible. Recent years have seen significant efforts to develop methods for breaking and simplifying MBA expressions. These efforts are driven by the need to analyse and understand obfuscated code, whether for debugging purposes, reverse engineering, or detecting malicious software. As obfuscation methods become more sophisticated, so do the techniques for breaking them.

In our research at the Christian Doppler Laboratory for Assurance and Transparency in Software Protection [L1], we focus on a novel methodology for generating strong and verifiable MBA expressions based on the concept of equality saturation. In particular, we build e-graphs for the generation of arbitrarily complex MBA expressions.

In 2009, Tate et al. [2] proposed equality saturation as a new optimisation technique which is based on the e-graph data structure. An e-graph is a graph structure that represents a congruence relation over a set of expressions. It consists of equivalence classes (e-classes), each containing equivalent nodes (e-nodes). E-nodes are unique, and the children of e-nodes are references to e-classes. Term rewriting involves transforming a term based on a set of possible rewriting rules without losing its semantics. E-graphs can efficiently express these equivalent terms.

Equality saturation is a technique for program optimisation based on the e-graph structure. Simply put, equality saturation explores all expressions possible within the existing rewrite rules and then selects the best one (e.g. fastest) for a specific use case based on a cost function. The advantage over iterative term rewriting is that equality saturation can find global optima.

The fundamental idea behind our novel approach is to construct strong opaque predicates – expressions that always evaluate to true or false but are difficult to analyse – from simple

<figure><img src="image_30.png" /><figcaption>Figure 1: Building an e-graph with one simple rewriting rule.</figcaption></figure>
MBA expressions. Using equality saturation, these simple expressions are transformed into more complex ones that are semantically equivalent but much harder to understand and analyse. This transformation is guided by an e-graph structure, where rewriting rules are applied iteratively to generate increasingly complex expressions. While e-graphs and equality saturation have previously been used for deobfuscation of MBA expressions, we revere this process and generate arbitrarily complex expressions from simple ones.

Our research involved creating a comprehensive set of rewriting rules that describe equivalent expressions, ranging from basic arithmetic properties to more complex transformations. For example, a simple rewriting rule might describe the commutative property of multiplication, where the expression (a * b) can be rewritten as (b * a). A more complex rule could involve the transformation of an expression involving bitwise negation, such as rewriting ~-(a + b) as (~a + ~b + 1). These rewriting rules were manually and systematically generated to cover a wide range of possible transformations, ensuring that the resulting MBA expressions are both complex and semantically equivalent to the original expressions.

To create arbitrarily complex MBA expressions starting from a randomly chosen simple expression, an increasingly complex e-graph is generated iteratively by applying these rewriting rules. Figure 1 illustrates the concept using a trivial example. Our starting point for the construction of a complex MBA expression is the term (a & b) | b. The only rewriting rule applied to the e-graph is the commutative rule (a & b) = (b & a). Iteratively, many more rewriting rules are applied until a complex e-graph containing all possible equivalences emerges. Each iteration of this process results in a more complex expression, ultimately leading to an MBA expression that is highly resistant to analysis.

In conclusion, our research introduces a novel methodology for generating complex and verifiable MBA expressions by leveraging the concepts of e-graphs and equality saturation, providing a robust solution for generating arbitrarily complex opaque predicates used for software protection.

**Links:**

[L1] https://cdl-astra.at

**References:**

[1] Y. Zhou, et al. "Information hiding in software with mixed boolean-arithmetic transforms," in Int. Workshop on Information Security Applications, pp. 61–75, Springer, 2007.

[2] R. Tate, et al. "Equality saturation: a new approach to optimization", in Proc. of the 36th annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pp. 264–276), 2009.

**Please contact:**

Caroline Lawitschka, Christian Doppler Laboratory for
Assurance and Transparency in Software Protection, Faculty
of Computer Science, University of Vienna, Austria
caroline.lawitschka @univie.ac.at

# GLITCH: Polyglot Code Smell Detection in Infrastructure as Code

by Nuno Saavedra, João F. Ferreira (INESC-ID and University of Lisbon) and Alexandra Mendes (INESC TEC and University of Porto)

GLITCH is a versatile tool designed for detecting code smells in Infrastructure as Code (IaC) scripts across multiple technologies. Developed by researchers from INESC-ID (Lisbon), INESC TEC (Porto), Instituto Superior Técnico / University of Lisbon, and the Faculty of Engineering / University of Porto, GLITCH automates the detection of both security and design flaws in scripts written in Ansible, Chef, Docker, Puppet, and Terraform. By using a technology-agnostic framework, GLITCH aims to improve the consistency and efficiency of code smell detection, making it a valuable resource for DevOps engineers and researchers focused on software quality.

As Infrastructure as Code (IaC) scripts become increasingly critical for automating IT infrastructure, ensuring their consistency and security is essential [1, 2]. Code smells – patterns that suggest potential issues – can lead to vulnerabilities, inefficiencies, and maintenance difficulties. GLITCH addresses these concerns by detecting a wide range of smells across multiple IaC languages, including security, design, and implementation flaws.

The GLITCH project is supported by a collaboration of researchers focused on enhancing software engineering practices. Their combined expertise aims to improve the quality and security of software systems through the development and application of this technology-agnostic tool.

**Motivation**

As organisations increasingly rely on IaC to automate and manage their infrastructure, the risk of introducing issues or vulnerabilities through poorly written or insecure code has become a significant concern. For example, Facebook's outage in 2021 was triggered by a misconfiguration in their internal backbone network, leading to disruptions in communication between data centres. This issue disconnected Facebook's services and tools, making it impossible to diagnose and resolve the problem quickly. During the day of the outage, shares in the company dropped by nearly 5% and Facebook CEO Mark Zuckerberg's wealth fell by more than $6 billion. According to a report produced by Fortune and Snopes, Facebook lost at least $60 million in advertising revenue. In the developing world, the outage disrupted daily life as Facebook's platforms are key for communication. In conflict zones like Syria, aid workers relied on WhatsApp to share bombing locations for safe travel but were unable to do so during the outage.

Traditional tools for detecting code smells in IaC scripts often focus on specific technologies and are developed independently, leading to inconsistencies and a lack of comprehensive coverage. GLITCH was conceived to address these gaps by of-
<figure><img src="image_31.png" /><figcaption>Figure 1: GLITCH's architecture overview.</figcaption></figure>

fering a unified, technology-agnostic approach to code smell detection. By detecting and mitigating code smells early in the development process, GLITCH aims to prevent potential security vulnerabilities, reduce maintenance costs, and enhance the overall quality of IaC scripts.

GLITCH is open-source [L1] and its development began in 2022. As the project progressed, it expanded to include design and implementation smells and extended its support to Docker and Terraform [2]. Preliminary results have already demonstrated GLITCH's effectiveness in detecting a broad range of code smells. The project is ongoing, with continuous improvements being made to enhance its capabilities and extend its applicability to new IaC technologies.

## Aim and Techniques Employed

By providing a unified approach to code smell detection, GLITCH seeks to reduce the effort required to develop and maintain secure and high-quality IaC scripts. Additionally, the project aims to create large datasets of IaC scripts and code smells that can be used by researchers and practitioners to further advance the field of software quality and security.

GLITCH approaches code smell detection by transforming IaC scripts into an intermediate representation. This representation captures common concepts across different IaC technologies, enabling the development of code smell detectors that are not tied to any specific language or tool. The framework uses both rule-based and algorithmic approaches to detect various smells. For security smells, a rule-based approach is used, while design and implementation smells are detected using more complex algorithms. The tool traverses the intermediate representation of the scripts, applying multiple analyses to identify all potential code smells. Figure 1 shows GLITCH's architecture overview.

Academically, it contributes to the field of software engineering by providing a novel, unified framework for code smell detection in IaC scripts. Practically, it offers a valuable tool for DevOps engineers, system administrators, and organisations that rely on IaC to manage their infrastructure. By improving

the security and quality of IaC scripts, GLITCH helps organisations prevent potential vulnerabilities and reduce the costs associated with maintaining complex infrastructure systems.

## Future Activities

The team aims to refine the existing detection mechanisms to improve their precision and recall. Another significant future activity is the creation of oracle datasets for design and implementation smells, similar to those already developed for security smells. These datasets will be used to evaluate the effectiveness of GLITCH and to facilitate further research in the field. Current efforts also include automated program repair of IaC scripts at the level of GLITCH's intermediate representation.

In conclusion, GLITCH represents a significant step forward in the field of software security, particularly in the context of IaC. By providing a comprehensive, technology-agnostic tool for code smell detection, GLITCH helps ensure that IaC scripts are secure, consistent, and maintainable, ultimately contributing to the integrity and reliability of the software systems they support.

## Link:

[L1] https://github.com/sr-lab/GLITCH

## References:

[1] N. Saavedra and J. F. Ferreira, "GLITCH: automated polyglot security smell detection in infrastructure as code," in Proc. of the 37th IEEE/ACM Int. Conf. on Automated Software Engineering, pp. 1-12, 2022.

[2] N. Saavedra, et al., "Polyglot code smell detection for infrastructure as code with GLITCH," in Proc. of the 38th IEEE/ACM Int. Conf. on Automated Software Engineering (ASE), pp. 2042-2045, IEEE, 2023.

## Please contact:

João F. Ferreira, INESC-ID and IST, University of Lisbon,
Lisbon, Portugal
joao@joaoff.com
# Comparability of Software Metrics and Estimating the Strength of Software Protections

by Patrick Kochberger, Philipp Haindl (St. Pölten University of Applied Sciences), Matteo Battaglin and Patrick Felbauer (University of Vienna)

In this project, we investigate how different tools measure code complexity of software protections, revealing significant variations in their results. While simpler metrics like lines of code (LOC) often produce similar outcomes, more advanced metrics such as cyclomatic complexity (CC) and maintainability index (MI) show major differences across tools. These discrepancies highlight the need for better methodologies when assessing the effectiveness of obfuscation techniques for protecting software.

In software development and software and program protection, techniques for estimating the complexity of source and/or program code are an important tool. On the one hand, when writing code, keeping it simple, easy to understand and employing efficient programming paradigms is a key requirement for long-term maintainability. On the other hand, in software protection, the goal is to make it as hard as possible to understand programs to increase the resilience against intellectual theft, tampering and exploitation. In this and the ongoing work at the St. Pölten University of Applied Sciences and the Christian Doppler Laboratory AsTra [L1], we focus on advancing the methodological foundations of software protection, particularly against adversary-at-the-end attacks, by studying and comparing code complexity metrics. Code metrics [1] are functions used for measuring certain properties of software. They are objective, reproducible and quantifiable measurements to gauge characteristics, e.g. the complexity of code. The resulting information is useful in a variety of applications of software development, including quality assurance, estimating performance, and costs. Specifically, these metrics are used to identify code which is overly complex, and not maintainable.

In software protection [2], code obfuscation is used to protect benign applications against attacks such as illegal distribution, intellectual theft, tampering, and exploitation. The idea is to intentionally increase the complexity of code in such a way that some functionality is more difficult to detect and/or understand. The goal is to make analysis of the application more time-consuming and difficult. To assess obfuscation techniques and obfuscation and deobfuscation tools and evaluate them against each other, one possible option is to compare the code complexity by measuring and calculating code complexity metrics.

In a first step towards comparable measurements, we performed a study on five different groups of code complexity metrics: Lines Of Code (LOC), Cyclomatic Complexity (CC), Halstead (Hal), Maintainability Index (MI), COnstructive COst MOdel (COCOMO), implemented and measured by 12 different tools. The LOC-related metrics quantify the size of a program by counting the number of lines. Each concrete metric and imple-

<figure><img src="image_32.png" /><figcaption>Figure 1: A small excerpt from our results on how six of the tools measure the cyclomatic complexity when facing a try-except construct in Python.</figcaption></figure>

mentation has its own rules regarding blank lines, comment lines, import lines, and non-executable lines. The CC measures the amount of decision logic based on the software's control flow graph. The Hal software metrics are a set of measurements based on the number of distinct operators and operands. The Halstead Difficulty is related to the complexity of the program. The MI is a weighted combination of Hal, CC, and LOC metrics. The COCOMO estimates software project effort and costs in person-months. The model relies on additional information, aside from the source code, such as the type of software project and its cost drivers to calculate its results. We surveyed the availability and differences among several code metrics across individual implementations in several tools. For a detailed investigation, we constructed a dataset containing different test cases and implemented an analysis framework which feeds the program code as a whole or piece-by-piece to the tools calculating the metric. In the piece-by-piece mode (e.g. line-by-line in Figure 1) the framework helps to find out which individual lines of code affect the overall metric score.

Our results indicate that the comparability of the tools' results varies significantly depending on the specific metric in question. For example, for the relatively simple LOC and source lines of code (SLOC) metrics, the tools calculated the most similar values, although even with these metrics, some tools had significant divergence. For the other studied metrics, some of the results were so different as to render them incomparable. Therefore, it is essential to not only specify the metric but also the tool which performed the measurements.

We plan to analyse even more code complexity metrics and want to evaluate their performance and capability in evaluating the strength of software protections. The goal is to find and develop measurements to compare code on different levels (source, intermediate, and binary code) to estimate the strength of protections before and after the compilation step as well as the effect of different compilers and optimisation passes.

Link: [L1] https://cdl-astra.at

## References:

[1] A. S. Nuñez-Varela, et al., “Source code metrics: a systematic mapping study,” J. of Systems and Software, vol. 128, pp. 164–197, 2017, doi: 10.1016/j.jss.2017.03.044.

[2] S. Schrittwieser, et al., “Protecting software through obfuscation: can it keep pace with progress in code analysis?,” ACM Computing Surveys, 2017. https://doi.org/10.1145/2886012

## Please contact:

Patrick Kochberger, St. Pölten University of Applied Sciences, Austria, patrick.kochberger@fhpst.ac.at
# Interactive Fuzzing Reveals Zero-Day Vulnerabilities in Several MQTT Brokers

by Steffen Lüdtke, Roman Kraus and Martin Schneider
(Fraunhofer FOKUS)

The growing number and diversity of cybersecurity attacks pose a challenge for developing secure systems, particularly in an age where many systems are connected to the internet. To facilitate early vulnerability detection, we propose an interactive fuzzing technique which employs grammars and supports genetic algorithms to interact with the SUT. This technique can generate inputs for specific attack scenarios, which are useful for finding new vulnerabilities and for assessing the completeness of patches. The proposed technique found zero-day vulnerabilities in established MQTT brokers within a few minutes.

## Fuzzing and Genetic Algorithms

Fuzzing is a testing technique where a system under test (SUT) is confronted with randomly generated inputs to test for its robustness and security. Grammar-based fuzzing is a form of fuzzing which uses grammars to support the input generation [1]. Grammars can specify the structure of an input format, messages and message sequences and thus raise the probability of creating syntactically valid inputs and interactions with the SUT. This increases the likelihood of testing deeper functionalities compared to fully random input generation. Nevertheless, the random nature of fuzzing makes it difficult to efficiently generate inputs which fulfil a specific goal, e.g. inputs which particularly stress the resources of a SUT. Therefore, inputs for a given attack scenario (e.g. denial-of-service attacks) cannot be efficiently generated.

Genetic algorithms are an optimisation technique inspired by natural evolution. The idea is to start with a random set of solutions for a problem and to improve it through an iterative process of selection, recombination, and mutation. In the selection process, a subset of individuals is chosen based on a problem-specific fitness function to create the next generation (e.g. the top 30%). Their traits are then exchanged (recombination) and mutated to populate the next generation. This ini-

tially keeps advantageous traits and then develops them via recombination and mutation.

Genetic algorithms have been previously employed with fuzzing to, e.g. increase the code coverage. We employ genetic algorithms to create inputs and optimise them towards user-defined vulnerability indicators. This allows us to efficiently create inputs for specific attack types, which can be useful for finding new vulnerabilities and for assessing the quality of patches. We achieve this by specifying observable symptoms of a successful attack on the SUT instead of specifying the characteristics of the inputs, which are often more difficult to determine in advance.

## MQTT and Mosquitto

Our case study is the Eclipse Mosquitto broker [L1]. This is a broker for the MQTT protocol, which is a prominent protocol for data exchange (e.g. telemetry) in the Internet of Things (IoT). MQTT implements a publish-subscribe model. This means that clients can publish messages under a specific topic to a broker which then forwards these messages to clients which have subscribed to that topic. Eclipse Mosquitto is a popular MQTT broker, which is implemented in C. It is therefore potentially vulnerable to memory errors like use-after-frees, segmentation faults or memory leaks. Mosquitto's wide usage, which includes industry settings, makes it a relevant case study.

## Architecture

Figure 1 provides an overview of our fuzzing architecture. The test case generation is done by Fuzzino [L2], a fuzzing library developed by Fraunhofer FOKUS. It receives as input ABNF grammars, which describe individual MQTT message types and valid message sequences. Fuzzino uses these grammars to derive test cases, which each constitute one sequence of MQTT messages. Within the grammars we use a custom meta language, which models relationships that normally cannot be expressed with context-free grammars. For example, we use symbols which are resolved to dynamically calculated length fields or which define implicit relationships between symbols (e.g. between a password flag and a password field). This increases the validity of inputs we generate and thus increases the scope of functionalities we can test.

Once Fuzzino has derived an initial generation of test cases, it starts executing them against the MQTT broker, e.g. Mosquitto. For this, it first contacts a supervisor that starts and

<figure><img src="image_33.png" /><figcaption>Figure 1: The fuzzing architecture that includes Fuzzino, the supervisor for the SUT and the SUT, showing the interaction between these components.</figcaption></figure>
stops the MQTT broker before and after each test case. This is necessary to match findings to individual test cases and to detect errors which only become evident on termination (e.g. memory leaks). We collect vulnerability metrics for each executed test case. This might be, e.g. the time which the broker needs to respond or the code coverage we achieve. Some of these metrics can be measured directly (e.g. the response time), while others require additional monitoring systems or instrumentations. Memory errors for instance are detected with the help of AddressSanitizer, which is an instrumentation that monitors memory accesses at runtime. The recorded metrics and findings are reported back to Fuzzino via the supervisor. Fuzzino then uses this data to calculate its fitness scores, produce the next generation and repeat this process until a pre-defined number of generations is reached.

## Evaluation

Our evaluation on Mosquitto suggests that our approach can be effective at systematically increasing targeted vulnerability indicators compared to fuzzing without genetic optimisation, e.g. in terms of the response time. Moreover, it could also be used to support the development of patches by producing diverse inputs for a vulnerability to ensure that the patch inhibits all ways a vulnerability may be triggered. For this, we use a fitness function which targets locations that trigger the vulnerability while also rewarding coverage diversity.

Furthermore, unguided, i.e. non-genetic fuzzing, was also effective. Namely, it found a bug within the current release of Mosquitto (2.0.18) in just a few minutes, which was confirmed to be a zero-day vulnerability. Furthermore, it found two unknown bugs on NanoMQ [L3], another MQTT broker we analysed. This highlights that unguided fuzzing can be especially useful if you want to broadly search for new vulnerabilities without specific attack scenarios or metrics in mind.

## Conclusion

The combination of grammar-based and genetic fuzzing is a powerful technique which can support testing systems with specific attack scenarios in mind. This might be the simple optimisation towards certain vulnerability indicators or more complex scenarios where a test suite is derived based on a specific vulnerability. Unguided fuzzing can complement this approach as a technique to analyse the security of a system without other goals in mind.

## Links:

[L1] https://mosquitto.org

[L2] https://www.fokus.fraunhofer.de/de/sqc/security_testing

[L3] https://nanomq.io

## Reference:

[1] S. Lüdtke, et al., “Attack-based automation of security testing for IoT applications with genetic algorithms and fuzzing,” IEEE QRS, doi: 10.1109/QRS-C55045.2021.00023

## Please contact:

Martin Schneider, Fraunhofer FOKUS, Berlin, Germany
martin.schneider@fokus.fraunhofer.de

Roman Kraus, Fraunhofer FOKUS, Berlin, Germany
roman.kraus@fokus.fraunhofer.de

# Verifying Code Correctness of Protected Software through Translation Validation

by Sebastian Schrittwieser (University of Vienna)

Software protection has evolved over the past three decades, but ensuring the correctness of protective code transformations remains a challenge. Our novel approach breaks down complex obfuscation techniques into smaller, manageable components and implements them as compiler passes. By using translation validation, the correctness of each transformation is ensured, resulting in more reliable and robust software protections.

Over three decades of software protection research and development have brought various protection techniques against code analysis, modification, and theft of binary code. However, a significant challenge is verifying the correctness of protective code transformations. While a lot of basic research has been done in the past in compiler correctness to ensure that functionality in binary programs matches the functionality described in the source code, there is no methodological basis for ensuring the correctness of code transformations for software protection.

Usually, software protections, such a code obfuscation, are applied at source code stage. However, in 2015 it was first shown that applying software protections directly in the compiler is feasible. Using compile-time obfuscation, we are able move the question of correctness of code transformations into a research area where we can build on a substantial body of prior work and methodologies. With Alive [L1] Lopes et al. introduced a refinement checker for the LLVM compiler infrastructure in 2015. The basic idea of so-called translation validation [1] is to compare an unoptimised code block with an optimised version and either prove that the optimised version is a refinement of the unoptimised one, or that the refinement fails in at least one particular case using concrete input values as a counterexample. In the past, Alive was successfully used to identify several bugs in optimisation passes of LLVM, and developers of optimisations are encouraged to validate them before committing them to the LLVM code base.

In our research at the Christian Doppler Laboratory for Assurance and Transparency in Software Protection [L2], we build upon this solid foundation for translation validation to verify the correctness of obfuscating passes in LLVM. One major research challenge is reducing the complexity of transformations. While, in theory, Alive covers a large number of language constructs of the LLVM intermediate representation (IR), there are certain language constructs that are known to prevent the underlying SMT solver from solving the query in a reasonable time frame. These include floating points, wide integer divisions, and some complex memory operations. Thus, atomic implementations of typical real-world obfuscation techniques such as virtualisation or control flow flattening would generate code transformations that are too complex for
<figure><img src="image_34.png" /><figcaption>Figure 1: Control flow flattening obfuscation constructed from multiple compiler passes.</figcaption></figure>

translation validation. For this reason, we deconstruct complex software protection methods into their fundamental protection principles, which can be implemented as separate compiler passes for which translation validation is feasible. Nagra and Collberg [2] have defined eleven software protection primitives that formalise basic protection principles. These primitives range from covering an object worth protecting with another one (cover primitive) to duplicating an object to artificially increase the set of objects to be analysed (duplicate primitive) to detecting and responding to code tampering (detect-responds primitive). Starting from these eleven primitives, we create a set of basic obfuscation passes for LLVM and use a refinement checker for translation validation. Each pass can be parameterised to concretise its functionality. For example, for the detect-responds primitive different methods for the detection of code tampering can be selected such as calculating hash values of code sections.

These compiler passes can now be combined in any way to construct strong software protections. Figure 1 shows the basic concept using the example of the control flow flattening obfuscation technique. In this technique, the control flow graph of a program is modified so that all basic blocks are at the same hierarchical level. After executing a basic block, the control flow is directed to a central dispatcher, which determines the next basic block based on the current state of the program and jumps to it. Rather than implementing this technique atomically, we assemble it from a combination of small compiler passes whose functionality is further specified by parameterisation. The indirect primitive is used to construct the dispatcher. The reorder primitive changes the order of the basic blocks so that no conclusions can be drawn about the functionality of the compiled binary based on local proximity of basic blocks in the code. Finally, the split/merge and duplicate primitives can be used to further split larger basic blocks and duplicate blocks to increase the total number of blocks and thus make reverse-engineering more time consuming.

Currently, most of our transformations are deterministic, with the notable exception of the reordering primitive, which al-

lows the target structures to be randomly shuffled. Usually, determinism is a desirable goal for compilers. However, for binary software protections that do not perform inherently irreversible code transformations, it may be useful to promote code diversity through randomness. The verification of code correctness is not affected by the use of randomness, since translation validation always validates concrete instances of code transformations using refinement checkers instead of validating the implementation of the transformation pass. In our future work, we thus intend to investigate which forms of code diversity can be implemented and what effect they have on the strength of the resulting software protection.

**Links:**

[L1] https://alive2.llvm.org

[L2] https://cdl-astra.at

**References:**

[1] A. Pnueli, M. Siegel, and E. Singerman, “Translation validation,” in Tools and Algorithms for the Construction and Analysis of Systems: 4th International Conference, TACAS’98, held as part of the ETAPS’98 Lisbon, 1998, Proc. 4, pp. 151–166, Springer.

[2] J. Nagra and C. Collberg, “Surreptitious software: obfuscation, watermarking, and tamperproofing for software protection,” Pearson Education, 2009.

**Please contact:**

Sebastian Schrittwieser, Christian Doppler Laboratory for
Assurance and Transparency in Software Protection, Faculty
of Computer Science, University of Vienna, Austria
sebastian.schrittwieser@univie.ac.at
# A Framework for the Analysis of Physical Unclonable Function Interfaces

by Chenglu Jin (CWI) and Marten van Dijk (CWI and Vrije Universiteit)

> For a long time, process variations in the manufacturing of computer chips has been a big hurdle for producing high-quality products. However, one can turn these imperfections caused by the process variations into something good: into unique random functions that are impossible to clone even by the original manufacturer. At CWI in Amsterdam, we are building a solid foundational understanding of these security primitives and bringing them closer to practice. This could be very interesting for use in computer systems and embedded systems, like cloud servers and controllers in critical infrastructures.

A Physical Unclonable Function (PUF) is a hardware security primitive, and its input-output behaviour (also called Challenge-Response Pairs or CRPs) depends on the uncontrollable and unclonable manufacturing process variation introduced in the manufacturing process of a semiconductor chip [1]. Hence, even the same manufacturer cannot physically clone a fabricated PUF device with the same behaviour.

One classical PUF design is Arbiter PUF (originally introduced by Marten van Dijk and his collaborators), as shown in Figure 1. It consists of a chain of switch components and ends with an arbiter. Each switch component propagates the two inputs on the left to the two outputs on the right via either the crossed paths or the parallel paths, depending on the value of the top selection bit input. Since the delay difference between the selected pair of paths is designed to be as small as possible, the main factor that will affect the delay difference is the manufacturing process variations. To evaluate an Arbiter PUF, the user first provides challenge bits to the selection bits of the switch chain and then sends a pulse signal from the left end of the switch chain. Every challenge-response pair should only

depend on the process variation in the delay difference selected by the challenge bits.

This unclonable feature allows PUF to enable many security applications. The most traditional use case of PUF is device authentication. Since there are no two PUFs in the world that have the exact same input-output behaviour, a verifier is able to remotely check whether the counterparty holds the PUF by checking whether the prover can send the responses to a few random challenges chosen by the verifier. The verifier just needs to compare the responses from the prover with the responses stored in its CRP database collected when it holds the PUF. If the prover does not hold the PUF at the moment, the prover will not be able to generate the correct responses, even if it had access to the PUF before. This is because the possible challenge space of the PUF is extremely large; without knowing which challenges will be selected by the verifier beforehand, the probability of the dishonest prover successfully predicting the used challenges would be extremely low. Thus, PUF provides a very lightweight and reliable method to perform device authentication in practice. Moreover, PUFs can be used to construct secure cryptographic protocols, like key agreement, oblivious transfer, and bit commitment.

PUF is also very useful in providing architectural support for software security. For example, PUF can be used for key management and remote attestation. PUF-based key management has a unique advantage over traditional key management, which stores secret keys in a digital memory. A digital memory may be vulnerable to probing attacks. A PUF-based key management scheme uses the responses of a PUF as the secret keys, while only the corresponding challenges need to be stored in a digital memory, which can be public information known by attackers. The secret keys will only be revealed during the runtime after the PUF has been fed with the stored challenges. Additionally, one can further extend this idea to construct secure remote attestation protocols, where a verifier will be able to check whether the outsourced code and data are executed on the authenticated processor embedded with a genuine PUF.

All of the above use cases have demonstrated the promising potential of the PUF technology, and the security of these protocols can be reduced to the security of the PUF itself. However, attackers could also build a mathematical clone of a

<figure><img src="image_35.png" /><figcaption>Figure 1: The basic operation of an Arbiter Physical Unclonable Function. Physical properties of chips like these are unique. Their uniqueness can be used to add security to critical infrastructure systems.</figcaption></figure>
PUF that can predict all of its CRPs. Even with some of the state-of-the-art PUF designs, advanced modelling attacks can still achieve substantially better accuracy (e.g. 75%) than random guesses (50%). So, until now, this type of attack has significantly undermined the security of the PUF and any security protocols or mechanisms built on it.

To solve this problem, we would want PUFs to have the same behaviour as a physical random oracle. A random oracle is supposed to generate an independent random value output from a uniform distribution when given a new and unseen input, and if it receives an input that has been queried before, it should reply with the same output as last time. However, PUF evaluations are sensitive not only to the process variations but also to measurement noise. Thus, sometimes, even the same challenge will lead to different responses on the same PUF. To overcome the reliability issue, one needs to post-process raw PUF responses before revealing them to the adversary. One popular post-processing method is called fuzzy extractor, and it is designed to extract a reliable secret string from a fuzzy input, which is the raw PUF responses [2]. However, to keep the security of the whole system, the computation inside the fuzzy extractor has to be kept secret from the adversary.

In our recent work, we introduce a theoretical framework that does not require any confidential digital computing while we can still prove rigorous statements about the bit security of a system that interfaces with the PUF [3]. The framework is even secure when the adversary has a prediction model (e.g. with a 75% accuracy). In particular, we proved the bit security of a PUF-based random oracle construction. This merges the PUF framework with fuzzy extractors. This gives hope for us to rigorously analyse the security of all the systems and protocols built on top of PUF.

**Link:**

[L1]: https://www.cwi.nl/en/groups/computer-security/

**References:**

[1] B. Gassend, et al. "Silicon physical random functions," in Proc. of the 9th ACM Conference on Computer and Communications Security, 2002.

[2] Y. Dodis, L. Reyzin, and A. Smith, "Fuzzy extractors: How to generate strong keys from biometrics and other noisy data," Advances in Cryptology-EUROCRYPT 2004: Int. Conf. on the Theory and Applications of Cryptographic Techniques, Interlaken, Switzerland, 2004. Proceedings 23, Springer, 2004.

[3] M. van Dijk and C. Jin. "A theoretical framework for the analysis of physical unclonable function interfaces and its relation to the random oracle model," J. of Cryptology, 36.4 (2023): 35.

**Please contact:**

Chenglu Jin, CWI, the Netherlands
Chenglu.Jin@cwi.nl

Marten van Dijk, CWI, the Netherlands
Marten.van.Dijk@cwi.nl

# Enhancing Software Security in Hardware SoC Environments: A Heterogeneous Approach

by Radhen Hendarmawan (RISE)

In the rapidly evolving world of embedded systems, ensuring robust software security within System-on-Chip (SoC) environments is essential. At RISE, we explore a heterogeneous approach using Field-Programmable Gate Arrays (FPGAs) and develop toolkits to streamline hardware acceleration, offering software developers powerful solutions to bolster security and performance.

The rise of embedded systems across various industries has led to the widespread adoption of System-on-Chip (SoC) architectures, which integrate multiple components such as CPUs, memory, and custom hardware blocks onto a single chip. These systems, while compact and efficient, present unique challenges, especially in terms of software security. As cyber threats continue to grow in sophistication, securing SoC environments against vulnerabilities like Man-At-The-End (MATE) attacks, malware, and hardware trojans has become critical.

Traditional software-based security measures often struggle to keep up with the demands of SoC environments, particularly due to constraints related to power, processing capability, and the heterogeneous nature of these systems. To address these challenges, researchers at RISE have been investigating a heterogeneous approach to software security, leveraging FPGAs for their flexibility, performance, and energy efficiency. Additionally, we have developed a toolkit and framework that simplifies the process of creating hardware accelerators, enabling software developers to rapidly prototype and implement security solutions with minimal expertise in hardware complexity.

**Why a Heterogeneous Approach?**

SoC systems typically combine CPUs, GPUs, and custom hardware blocks, necessitating a multifaceted approach to security. Integrating FPGAs into these systems provides several advantages:

1. Performance Efficiency: FPGAs excel in executing cryptographic algorithms, such as the Advanced Encryption Standard (AES), much faster than traditional processors due to their parallel processing capabilities. This is crucial for applications that require real-time data protection, such as secure communications and digital rights management.

2. Energy Efficiency: Power consumption is a key concern in embedded systems, particularly for battery-operated devices. FPGA-based implementations of security algorithms have demonstrated significantly lower power consumption compared to software-based solutions on CPUs or ARM processors, making them ideal for energy-constrained environments.

3. Flexibility and Reconfigurability: Unlike fixed-function hardware, FPGAs can be reprogrammed to adapt to evolv-
ing security threats or to implement different security protocols as needed. This reconfigurability allows for the dynamic adaptation of security measures, providing a robust defence against emerging cyber threats.

## Toolkits and Frameworks for Rapid Prototyping

One of the challenges in leveraging FPGA technology is the complexity involved in designing hardware accelerators, which often requires specialised knowledge in hardware design and troubleshooting. To overcome this barrier, our team at RISE has developed a toolkit and framework that facilitates the rapid prototyping of hardware accelerators using high-level synthesis (HLS). This HW-SW co-design solution is designed to help software developers create Hardware Intellectual Property (IP) and accelerators without needing extensive expertise in hardware complexity.

Our toolkit streamlines the process of developing FPGA bit-streams by abstracting the low-level hardware details and providing a user-friendly interface for defining and configuring hardware functions. This allows developers to focus on software security algorithms and leave the intricacies of hardware design to the automated tools. The framework supports various high-level programming languages, enabling seamless integration with existing software workflows and reducing the time required to bring new security features to market.

## Case Study: AES Implementation on FPGA

To demonstrate the effectiveness of our approach, we conducted a study comparing the performance, resource utilisation, and power consumption of AES implementations on different hardware platforms: CPU, ARM, and FPGA. The results were compelling:

* Performance: The FPGA implementation of AES128 achieved encryption latencies of 20ms, compared to 250ms on ARM and 100ms on CPU. This performance boost is essential for applications where speed is critical, such as in secure real-time communications.

* Resource Utilisation: While the FPGA required more resources, such as Look-Up Tables (LUTs) and Block RAMs (BRAMs), the trade-off was justified by the significant gains in performance and energy efficiency. Our toolkit played a crucial role in optimising resource usage, enabling efficient implementation without sacrificing performance.

* Power Consumption: The FPGA implementation consumed less power during encryption operations compared to both ARM and CPU platforms, underscoring its suitability for energy-sensitive applications like IoT devices.

## Future Directions and Implications

The integration of FPGAs in SoC environments represents a significant advancement in software security. By leveraging their unique capabilities and our rapid prototyping toolkit, we can develop security solutions that are not only more efficient but also more adaptable to the ever-changing cyber threat landscape. Looking ahead, our research will focus on expanding the toolkit to support additional security mechanisms, such as secure key management and real-time intrusion detection, within FPGA-based SoCs.

This heterogeneous approach to software security holds immense potential across a wide range of applications, from consumer electronics to critical infrastructure. As cyber threats continue to evolve, the ability to dynamically adapt security measures will become increasingly important. At RISE, we are committed to advancing this field and providing the tools and solutions that will help safeguard the next generation of embedded systems.

## Links:

[L1] Advanced Encryption Standard (AES) Overview: https://kwz.me/hDV

[L2] Introduction to FPGAs: https://kwz.me/hDW

## References:

[1] Xilinx, "Vivado design suite user guide: high-level synthesis," UG902, 2023.

[2] M. Tehranipoor and F. Koushanfar, "A survey of hardware trojan taxonomy and detection," IEEE Design & Test of Computers, vol. 27, no. 1, pp. 10-25, 2010.

## Please contact:

Radhen Hendarmawan, RISE, Sweden
hendarmawan@rise.se

# Side-Channel Resistant Applications through Co-designed Hardware/Software: the SCRATCHS Project

by Frédéric Besson, Célia Le Du (Inria), and Pierre Wilke (Centrale Supélec Rennes)

Hardware and software solutions for protecting against timing side-channel attacks are effective in securing sensitive data, but significantly impact the performance of the programs they protect. The SCRATCHS project, which stands for Side-Channel Resistant Applications through Co-designed Hardware/Software, aims to combine security and execution speed by developing a new hybrid protection solution based on hardware and software co-design.

Observing fingerprints left on a building's keypad to guess the entry code, or analysing the sound of keyboard keys to deduce a typed password are examples of side-channel attacks. These attacks are numerous and extend into more advanced cybersecurity contexts. This type of attack involves extracting sensitive information by observing and interpreting signals emitted by a computer system. Attackers use information such as the execution time of a program, its power consumption, or the state of the memory cache to deduce cryptographic information, such as encryption keys.

The SCRATCHS project aims to create a new protection solution that combines hardware and software solutions, focusing
particularly on cache-based timing side-channels. This solution would ensure security while maintaining high performance.

Started in 2021, this project is supported by the LabEx CominLabs and brings together researchers located in Rennes, Lorient, and Brest, working in the Lab-STICC and IRISA research laboratories. These researchers are affiliated with institutions such as INRIA, CentraleSupélec, ENSTA Bretagne, and the University of South Brittany. SCRATCHS benefits from collaboration among experts in the fields of formal methods, software-hardware interface security, hardware design, and microarchitecture.

<figure><img src="image_36.png" /><figcaption>Figure 1: For a given secret key (0x42), the hit rate for each cache set (on the Y-axis) is shown relative to the first byte of the plaintext (X-axis). In the unprotected case, discernible patterns allow information about the secret key to be recovered. In the locked case, the hit rate remains constant, making the attack ineffective. (Figure adapted from [1]).</figcaption></figure>

## Hardware and Software Countermeasures

The main types of hardware countermeasures against cache-based side-channel attacks are randomisation and partitioning. In the first case, the address-to-cache-set mapping may be randomised. Randomisation alters the links between the cache areas that are accessed and the memory areas visited in the sensitive application. The mapping between memory areas in the application and the cache areas is randomised. However, this random mapping needs to be changed regularly. In the second case, the cache can be partitioned into multiple security domains, preventing attackers from inspecting and modifying the state of the cache corresponding to the domain where the secure data applications reside. These approaches induce overhead and slow down the programs by protecting all data, including that which does not require protection.

Software countermeasures, on the other hand, operate independently of the underlying hardware and thus do not rely on the mechanisms of the hardware in question. Constant-time programming, which could be a solution, forbids memory accesses based on secret data as well as conditional branches with conditions dependent on a secret. Although effective, this type of programming is prone to errors and also induces overhead.

## The SCRATCHS Solution: a Fine-grained Dynamic Partitioning Mechanism via Cache Locking

SCRATCHS involves the co-design of a RISC-V processor and a compiler toolchain to ensure the security of sensitive data while maintaining optimal program execution speed. This hybrid solution aims to enable communication between software and hardware components to reduce the risk of secret data recovery only when necessary.

To put this into practice, dynamic partitioning is used, where the sensitive program can instruct the system to always keep sensitive data in the cache, a process known as locking. As long as this data is locked, it cannot be evicted from the cache, and all accesses to it are necessarily cache hits. Access to sensitive data will thus always take the same quick time, preventing the attacker from using access time measurements to decode secret data. Figure 1 illustrates a PRIME+PROBE [3]

analysis after one round of AES. This shows that our locking mechanism prevents the attacker from learning information about the secret key. Through this process, the necessary data is locked in the cache until operations are completed, and the rest of the cache remains available for other applications, maintaining optimal performance.

Technically, this involves modifying the processor and the cache. Lock and unlock commands are added to the instruction set architecture, specifically the RISC-V ISA [1]. Meanwhile, mathematical calculations on the security of this solution have provided formal proof of this co-design approach [2].

The SCRATCHS project will conclude in 2025 and will give way to the follow-up action LockOS. The goal of LockOS will be to implement the developed solutions on more complex processors with different privilege levels while adding operating system support. The aim is to create a demonstration to prove that the developed protections can achieve a high level of security while maintaining strong performance.

## References:

[1] N. Gaudin et al., "A fine-grained dynamic partitioning against cache-based timing attacks via cache locking," ISVLSI, 2024.

[2] J.-L. Hatchikian-Houdot et al., "Formal hardware/software models for cache locking enabling Fast and Secure Code," ESORICS, 2024.

[3] F. Liu et al, "Last-level cache side-channel attacks are practical," SP 2015.

## Please contact:

Frédéric Besson, Inria, France
frederic.besson@inria.fr
# Protecting Cryptographic Material in Ethereum Blockchain Clients Using an Open-source Secure Element

by Mario de la Haba Navarro (Decentralized Security), Pablo Sánchez-Serrano (University of Malaga), and Isaac Agudo (Decentralized Security and University of Malaga)

A recurring security issue in software is protecting cryptographic material, especially for cloud-hosted or internet-facing applications, where the risk of key compromise is higher. One solution is using a Hardware Security Module (HSM), which secures keys and performs cryptographic operations without exposing them. However, HSMs are typically closed source, making security evaluations difficult, and may not support the latest cryptographic methods. For over three years, we've been developing an open-source modular platform to build an HSM for Ethereum clients, a crucial part of the blockchain infrastructure.

Relying on security through obscurity is an approach that can present significant risks. Security by obscurity is based on the premise that a system is more secure if the details of its implementation are unknown. However, this approach can be problematic because if implementation details are discovered, the security of the system may be compromised. There are many examples in the literature of closed systems that were immediately broken once the source code was recovered, but even

without the source code, a side-channel can compromise the security of the system. In September 2024, a researcher from NinjaLab published EUCLEAK [L1], an attack that affects ECC keys in the Infineon SLE78 secure element. This is the main component on many different hardware authentication tokens, such as the Yubikey 5 tokens, one of the most widespread FIDO hardware tokens. This is not an isolated example – in 2017, researchers from Masaryk University presented ROCA [R1], an attack affecting the Infineon M7892 B11 chip due to a vulnerability in another closed-source library, this time affecting RSA keys. This shows that despite the risk, the industry is still supporting closed-source and hardware products.

The use of a Hardware Security Module (HSM) is widespread in the modern internet, as many cloud providers already provide some kind of key-management systems based on an HSM. Also, the use of HSM is a requirement in many critical systems, e.g. Root Certification Authorities. However, in the current blockchain security landscape there are not many examples of the use of HSMs, and most of them focus on protecting the private keys of the user wallets [2], leaving the keys of the validator nodes aside. We focused on the blockchain scenario because a blockchain client is a heavily exposed piece of software that is commonly run in the cloud. Also, there is an inherent economical risk associated with blockchain clients, because they need to have access to the cryptographic keys that are used to move funds, so an attacker compromising the machine could use them to empty the victim's wallet.

If we focus on the Ethereum blockchain, there is another incentive for trying to come up with an open-source HSM – the cryptographic algorithms they use are evolving faster than commercial products. Current consensus protocol makes use of Boneh-Lynn-Shacham (BLS) signatures, which is not a

widely used industry standard and hence not supported by traditional HSMs. To the best of our knowledge there is only one HSM manufacturer that claims to support this type of signature [L2], but as with many HSMs, its implementation is closed source. The next generation consensus protocol will probably make use of Zero Knowledge Proof (ZKP) protocols, so the HSM should evolve in sync with the network. Then it is not only a matter of having a more transparent HSM but also a more agile one.

Our goal in this project was to provide the base for an open-source HSM, using a low-cost hardware board, so that anyone can use it with their Ethereum node, without the cost of the hardware being a limitation. This means that developers and security experts can examine the code, identify potential vulnerabilities and contribute to improving the security of the implementation. In addition, we implemented our code using a hardware development kit that provides an open hardware design, allowing the community to also improve the hardware part. In Figure

<figure><img src="image_37.png" /><figcaption>Figure 1: Different deployment scenarios for the HSM in Ethereum.</figcaption></figure>
1 we can see the two different scenarios that we have consid-
ered when developing our project: a node operator with phys-
ical access to the node (Staker A), and a node operator running
the node in the cloud (Staker B). In the first case, the HSM
would be physically connected to the node, whereas in the sec-
ond case the HSM would need to connect to the node over the
internet, using either a cellular connection or the internet con-
nection of the node operator. For each scenario we tested a dif-
ferent hardware. We chose Nordic Semmiconductors
Development Kits as they provide a wide range of boards
based on the ARM Cortex-M33 CPU (e.g. nRF5340 DK,
nRF9160 DK and rRF7002 DK), with full support for ARM
TrustZone technology. Also, they provide an excellent SDK
based on the open-source RTOS Zephyr OS [L3], clear and
concise documentation and a very strong community.

This project was funded by the Ethereum Foundation [L4] and
has been developed in collaboration between Decentralized
Security [L6] and NICS Lab [L7]. All the code and more tech-
nical details can be found in the Github repository [L5].

Links:

[L1] https://njalab.io/eucleak/

[L2] https://kwz.me/hDM

[L3] https://zephyrproject.org/

[L4] https://kwz.me/hDQ

[L5] https://github.com/decentralizedsecurity/bls-hsm

[L6] https://decentralizedsecurity.es

[L7] https://www.nics.uma.es

References:

[1] M. Nemec et al., “The return of coppersmith’s attack: practical factorization of widely used RSA moduli,” ACM CCS, 2017. doi: 10.1145/3133956.3133969

[2] W. Shbair, E. Gavrilov, et al., “HSM-based key management solution for Ethereum blockchain,” in IEEE Int. Conf. on Blockchain and Cryptocurrency, 2021.

Please contact:

Isaac Agudo, Founder of Decentralized Security, Researcher
at NICS Lab, University of Málaga, isaac@uma.e

CALL FOR PAPERS

ACM Digital Threats:
Research and Practice

Special Issue on Offensive and
Defensive Techniques in the Context of
Man At The End (MATE) Attacks

Guest Editors:

* Michele Ianni,
  University of Calabria, Italy,
  michele.ianni@unical.it

* Sebastian Schrittwieser,
  University of Vienna, Austria,
  sebastian.schrittwieser@univie.ac.at

MATE (Man-At-The-End) is an attacker model where an adversary has access to the target software or hardwareenvironment of his victim and the ability to observe and modify it in order to extract secrets such as cryptographickeys or sensitive information, possibly with the subsequent goal of altering code integrity or inserting backdoors,among others. A typical example of such a scenario is the case of an attack on a stolen smartphone or againstsoftware leveraging protection to hide sensitive data or intellectual property.

The main focus of the special issue on
Offensive and Defensive Techniques in
the Context of Man At The End
(MATE)Attacks is on new models and
techniques to defend software from
tampering, reverse engineering, and
piracy aswell as to the development of

new attack strategies that highlight the
need of more complete defenses. We in-
cludeboth offensive and defensive tech-
niques because of their close and inter-
twined relationship depending on theat-
tack scenario: indeed, reverse engineer-
ing is defensive when the goal is to an-
alyze obfuscated malware, but it isof-
fensive when it is used to steal intellec-
tual property and assets in legitimate
software. Likewise, obfuscation isde-
fensive when it aims for protecting a le-
gitimate asset against reverse engineer-
ing, while it is offensive if it is usedto
hide that malware is embedded in an
application. Both scenarios are of prac-
tical relevance, and therefore thespecial
issue on Offensive and Defensive
Techniques in the Context of Man At
The End (MATE) Attacks includes al-
lattacks on/defenses of the confidential-
ity and integrity of software applica-
tions and assets embedded therein and-
exposed to MATE attacks. In such sce-
narios, attackers have full control over,
and white-box access to, the software-
and the systems on which they attack
the software in their labs.

Strongly encouraged are proposals of
new, speculative ideas, metrics, tools,
and procedures for evaluating tamper-
proofing, watermarking, obfuscation,
birthmarking, and software protection
algorithms in general. Assessment of
new or known techniques in practical
settings and discussions of emerging
threats, and problems are expected.
Likewise, reverse engineering of low-
level constructs such as machine code

or gate-level circuit definitions through
static and dynamic analysis is geared to
recover information to determine the
intent of programs and understand their
inner workings as well as for classify-
ing them with respect to similar known
code (which is typically malicious).
The special issue on Offensive and
Defensive Techniques in the Context of
Man At The End (MATE) Attacks wel-
comes original work on the formal in-
vestigation of software protection,
where formal methods are used to bet-
ter understand the nature, relations, po-
tentialities, and limits of software secu-
rity techniques.

Important Dates

* Submissions deadline:
  30 November 2024

* First-round review decisions:
  15 March 2025

* Deadline for revision submissions:
  30 April 2025

* Notification of final decisions:
  30 June 2025

* Tentative publication:
  30 September 2025.

Please contact:

Michele Ianni, University of Calabria,
Italy, michele.ianni@unical.it

Sebastian Schrittwieser, University of
Vienna, Austria,
sebastian.schrittwieser@univie.ac.at

For more information about topics
and submission, see
https://kwz.me/hDR
European Research and Innovation

# Connected Aquaponics: Sustainable Agriculture through Industry 5.0 Technologies and Circular Economy Principles

by Rafael Kupsa, Amin Anjomshoaa and Markus Tauber
(Research Studios Austria)

The EDEN project is at the forefront of sustainable agriculture, integrating Industry 5.0 technologies to improve upon aquaponics systems. This article explores how the project is developing innovative frameworks to maximise resource efficiency, optimise food production, and foster community engagement securely.

Aquaponics is a closed-loop system where the waste produced by fish is used as nutrients for plants, which in turn purify the water for the fish. This symbiotic relationship drastically reduces the need for water and land compared to traditional agriculture. EDEN is a two-and-a-half-year research project that began in April 2023, in collaboration with Research Studios Austria FG, the University of Applied Sciences St. Pölten, the Austrian Institute of Technology, BEIA International, and Andersfarm, an Austrian aquaponic expert, with the goal of enhancing aquaponics systems in two major steps: First, by creating hardware and software capable of intelligently optimising aquaponics systems using autonomous control loops, the Internet of Things (IoT), and machine learning (ML) technology, and second, by providing a secure platform for connecting multiple systems, allowing them to benefit from each other without compromising their data, if they so choose. As the project progresses, it holds the potential to transform aquaponics into a scalable and economically viable solution for food production, contributing to global efforts to address the challenges of food security and sustainability.

## Smart Optimisation in Aquaponics

Initially, the focus is on developing a software framework that integrates IoT and ML technologies within an autonomic control loop. This framework utilises the MAPE-K (Monitor, Analyse, Plan, Execute, Knowledge) loop, a well-established approach in autonomic computing that enables systems to self-manage by continuously monitoring their environment, analysing data, planning actions, executing them, and updating their knowledge base. This continuous cycle ensures that the system can adapt to changing conditions in real-time [1,2].

In the context of aquaponics, IoT sensors collect critical data such as water quality, temperature, and humidity. The data is then processed and analysed by ML algorithms, which can detect anomalies or predict potential issues. When irregularities are detected, the system can alert users about them and, in some cases, automatically initiate corrective actions via IoT actuators. Thus, the system can be helpful in optimising key parameters such as water quality, nutrient levels, and environmental conditions in aquaponics systems (see Figure 1).
One practical example of adaptive control within the EDEN project's aquaponics system is the regulation of pH levels. IoT sensors continuously monitor pH levels, while ML algorithms predict deviations from the optimal range. When an issue is detected, the system can alert the user of it and, depending on the setup, automatically adjusts the water's pH by adding necessary solutions with a pump, maintaining a healthy environment for both fish and plants. This automation reduces manual intervention, ensuring a more efficient and sustainable operation.

## Networked Systems for Community Benefit

Beyond optimising individual aquaponics systems, the EDEN project seeks to create a network of interconnected systems that share data, resources, and knowledge. This networked approach aligns with the principles of Industry 5.0, which emphasise collaboration and circularity and is modelled after Anjomshoaa and Curry's [3] maturity levels of knowledge sharing

and reuse in smart environments. Users will be able to connect via the project's website [L1], currently under development, at three levels:

1. Data level: The first level of community engagement involves data sharing among aquaponics operators. Users can upload data from their systems to a central platform, where it can be accessed by others. This collective data pool provides valuable insights and enables operators to learn from each other's experiences.

2. Stream level: At a more advanced level, the EDEN project envisions real-time data streaming, where aquaponics systems are continuously connected to the central platform. This allows for immediate sharing of data and fosters a collaborative environment where operators can benefit from the collective knowledge of the community.

3. Service level: The EDEN project also plans to facilitate the sharing of ML models among operators. By contributing their models to a shared repository, users can improve the accuracy and applicability of their systems. This federated learning approach ensures that all participants benefit from the collective advancements in technology, without compromising the privacy or security of their individual data.

This approach allows users to decide what and how much they want to share about their systems and how to contribute to improving models and data control. For example, an operator can provide the data of their pH sensors and their manual pH regulation while others can use those to initialise an automated pH-regulation model with a pH pump. The trained model could then be provided back to the user community. This collaborative approach accelerates knowledge sharing, allowing

the entire network to benefit from improved performance and resource efficiency.

As the EDEN project promotes interconnected systems and shared data, ensuring the security and privacy of the data is crucial. This can be addressed by implementing robust encryption protocols for data transmission, secure authentication methods for user access, and providing options for users to anonymise their data before sharing it. Users who do not want to share data at all due to privacy concerns can still contribute by sharing models within the federated learning approach.

## Links:

[L1] https://eden.researchstudio.at

## References:

[1] S. Maksuti, O. Schluga, G. Settanni, M. Tauber, and J. Delsing, "Self-adaptation applied to同期 via a generic autonomic management framework," in 2019 IEEE Int. Conf. on Industrial Technology (ICIT), pp. 1179-1185.

[2] S. Maksuti, M. Zsilak, M. Tauber and J. Delsing, "Security and autonomic management in system of systems," Infocommunications Journal, vol. XIII, no. 3, pp. 66-75, Sept. 2021. doi: 10.36244/ICJ.2021.3.7

[3] A. Anjomshoaa and E. Curry, "Transfer learning in smart environments," Machine Learning and Knowledge Extraction, vol. 3, no. 2, pp. 318-332, 2021.

## Please contact:

Rafael Kupsa, Research Studios Austria Forschungsellschaft mbH, Austria
rafael.kupsa@researchstudio.at

<figure><img src="image_38.png" /><figcaption>Figure 1: MAPE-K framework architecture for smart control of an aquaponics system.</figcaption></figure>
# An Innovative Approach to Supporting Startups in Greece and Southern Europe

by Panagiotis Konstantinopoulos, Vasileios Loukopoulos, Dionysia Mylona, Maria Veneri, and Konstantinos Bastas
(Patras Science Park S.A.)

**The Greek experience from operation of Science and Technology Parks (STPs) has demonstrated that the most important factors affecting operation of an STP are capacity building, and lack of funding for support of a wide range of services. A novel mechanism that will act as a Distributed Local Cluster is proposed for application in Balkan and Southern European countries.**

Mainstream current support services [1] for startups range from training/mentoring, seed funding, acceleration, supply of workspaces and admin support. However, reflecting on the starting of the development of Science and Technology Parks in Europe (in the 1970s), the situation was much simpler, and the range of offered services, beyond incubation, was limited. (Figure 1)

Patras Science Park (PSP) [L1] was established on the outskirts of the port city of Patras, at the centre of an RTD and innovation ecosystem, following the model of Incubator. Over the years, PSP extended its range and developed a number of added-value services. Two major problems have been identified concerning these services, related to sustainability and capacity building:

* Sustainability of operations, beyond the main incubation activities, is offered spontaneously, implemented mostly through funded projects.

* Capacity-building of existing staff, tenant startups' and other SMEs' key personnel is obstructed, due to lack of funding for the Greek STPs.

It is notable that these problems are common for most Southern European countries and, even more intensely, in the area of the Balkans, where lack of relevant infrastructure for supporting startups is more visible than in most EU member states.

## Step 1 – The SPREAD2INNO Project

The gap between the Northern and Southern European countries or between the strong and moderate or emerging innovators has been identified at EU level, as well as its adverse consequences (HORIZON-EIE-2021-SCALEUP-01-01 Call [L2]).

PSP participated in the above Call, as partner in a consortium consisting of leading organisations in the area of acceleration services towards startups, namely, Fondazione E. Amaldi (I), as Project Coordinator, Fraunhofer IPK (D), Teseas (I), Cleantech (BG), Minds & Sparks GmbH (A), including the Brussels-based European Business Angels Network (EBAN).

SPREAD2INNO [L3] brought together different innovation stakeholders – incubators, accelerators, innovation businesses, research organisations, consultancies and networks. The goal was to implement a scalable, replicable and holistic two-year programme for provision of high-quality business services, and collaboration between different entities of well-connected and less-connected regional innovation ecosystems, with immediate impacts at the local and EU level. In this context, the partnership implemented a set of activities such as six local events [2] including training courses, development of an online platform as a single point of reference for information exchange between different innovation ecosystems, two intensive training academies, and a one-week business case and investor training for six finalists.

Two out of the six local events were implemented in Greece:

* The first one took place on 24 and 25 May 2023, in Thessaloniki, co-organised by PSP and EBAN, in parallel with the EBAN Annual Congress for 2024.

* The second one took place on 26 and 27 November 2023, in Patras, in parallel with the 8th Annual Patras IQ Fair.

<figure><img src="image_39.png" /><figcaption>Figure 1: Historical account of supporting services for startups.</figcaption></figure>
<figure><img src="image_40.png" /><figcaption>Figure 2: Novel mechanism for supporting startups.</figcaption></figure>

The two academies were implemented in Bologna (I) and Sofia (BG), in parallel with WMF 2024 and Spinoff Bulgaria 2024, respectively, with participation of a total of five Greek startups.

Two Greek startups were selected for participation in the final step, i.e. the Startup Week one-week training and personalised mentoring, which will conclude the SPREAD2INNO project activities.

## Step 2 – The Distributed Local Networks (DLNs)

During implementation of the SPREAD2INNO project, it became evident among the PSP team that the task of supporting startups should be viewed in a more holistic manner, considering local weaknesses, and combining efforts and resources between all relevant, as well as interested, local stakeholders. The idea was to form “Distributed Local Networks-DLNs” that could cooperate, creating formal or informal networks, which could undertake jointly the task of providing support services to startups and SMEs. This way, the spectrum of services could be extended, the associated costs for the stakeholders could be lowered, and the startups could source the required services locally.

Testing of this novel methodology has already started by PSP, and will be demonstrated in nine different regions, in Greece, Italy, Slovenia, Croatia, Montenegro, Bosnia & Herzegovina, Serbia and Albania, with funding from the Interreg ADRION programme (project A4SUSTINNO).

## Step 3 – Distributed Local and Interregional Networks

At the end of the A4SUSTINNO project, the local networks (DLNs) will take advantage of existing links with investors and support organisations, through the SPREAD2INNO activities, and especially the EBAN and other pan-European networks, creating a network, which will be supported by dedi-

cated web platform for information, matching, and diagnosis of needs and weaknesses (Figure 2).

### Links:

https://psp.org.gr/

https://kwz.me/hDI

https://www.spread2inno.eu/

### References:

[1] “Business incubation – from startup to scaleup, A Policy Brief from the Policy Learning Platform for a smarter Europe,” Apr 2024.

[2] G. D'Agostinis, L. Scatena, E. Lombardi, K. Singer-Coudoux, H.N. Buxmann, P. Konstantinopoulos, D. Haskovic, and I. Todorova, “Challenges, disparities and risks of the European innovation system: the SPREAD2INNO project to bridge the gap,” 74th International Astronautical Congress (IAC), Baku, Azerbaijan, 2–6 Oct 2023.

### Please contact:

Panagiotis A. Konstantinopoulos, Patras Science Park, Greece
pkonst@psp.org.gr
# Boosting MATE Security through Small Language Models

by Luca Caviglione (CNR-IMATI), Gianluigi (CNR-ICAR), Massimo Guarascio (CNR-ICAR), and Paolo Zicari (CNR-ICAR)

Modern Man-At-The-End (MATE) attacks can take advantage of Language Models to produce deceptive information or malware variations. Fortunately, they can also be used to implement advanced defensive techniques. In this vein, we present the use of Small Language Models to reveal fraudulent communications or to automatically generate test cases for preventing the exfiltration of data through tampered MQTT brokers.

The typical MATE adversary is supposed to have an unrestricted access to the target. In modern heterogeneous scenarios, the attacker can interact with software artifacts (e.g. libraries, firmware and digital images) as well as with a multitude of hardware devices, such as IoT nodes or industrial-class assets. Therefore, available offensive tools and techniques are almost boundless, ranging from debuggers to virtualisation frameworks.

With the advent of generative AI, the ability of the adversary has expanded, making MATE attacks difficult to prevent and mitigate. For instance, Large Language Models (LLMs) can be used during the reconnaissance stage to gain insights from traffic dumps, execution logs, or documents for implementing a business process or instructing operators. LLMs can also be used to weaponise threats as they have proven to be effective in synthetising ad-hoc phishing mails or in producing malicious code, such as SQL injections (e.g. [1] and the references therein). Fortunately, LLMs are emerging as valuable defensive tools, especially for anticipating attackers. For instance, AI fuzzers can test libraries, configuration files and protocol specifications effectively [1], especially in preventing some manipulations that a MATE adversary is likely to perform when accessing the target.

Aiming to mitigate the impact of MATE attacks, we showcase two major results leveraging Small Language Models (SMLs). Unlike LLMs, they are trained on smaller, more specific, and cleaner datasets. This allows them to achieve better performances than LLMs for specific tasks without the need for supercomputers with huge computational resources, which is an unfeasible requirement for SMEs.

The first result considers the usage of SMLs for mitigating possible phishing attacks or communications crafted to induce human operators to support the attacker, for instance to grant access to an infrastructure. To this end, the threat actor could

<figure><img src="image_41.png" /><figcaption>Figure 1: Learning process of the Detection Model and interaction with the expert.</figcaption></figure>

<figure><img src="image_42.png" /><figcaption>Figure 2: The pipeline for generating “fake” MQTT topics for the creation of covert communications within real MQTT brokers. In red are the topics used as an example for describing the attack template.</figcaption></figure>
collect information on the used software, vendors, CVEs, or supported hardware to produce “fake news”, e.g. misleading security bulletins. As a countermeasure, we devised a human-in-the-loop semi-supervised framework for detecting ad-hoc malicious information in a challenging scenario where small amounts of labelled data are available for the training stage. It leverages the iterative Active Learning (AL) process for integrating newly labelled data. Specifically, it uses a “small” instance of a Bidirectional Encoder Representation from Transformers (small BERT) model within an AL scheme where novel labelled data is acquired incrementally, with the help of a human expert, and used to fine-tune the model. The learning process introduced above is depicted in Figure 1. In more detail, the initial set of training data is used to build a preliminary version of the classifier. This training set is expanded iteratively by automatically selecting a small subset of uncertain unlabelled data instances, which are passed to a human expert who will confirm or reject the model classification. By adding these newly labelled instances to the original training set, a new version of the classifier is trained at each iteration of the AL procedure. This framework has been tested for detecting fake news (e.g. gossip and politics) and has demonstrated its effectiveness with improvements in accuracy up to 10%.

The second result for limiting MATE attacks employs SMLs to help the security expert reveal the presence of a malicious actor trying to exfiltrate data through an MQTT broker, which is a core building block of many smart homes and an important “glue layer” to gather IoT measurements for feeding digital twins of cities and industrial settings. A malicious actor could collect MQTT topics of the victim (e.g. a smart building) through a MATE attack and then craft “fake” entries to implement a wide array of information-hiding-capable offensive schemes. Such bogus entries can be used to conceal unauthorised transmissions or encode stolen data, e.g. the creation of a specific topic could signal infected IoT nodes to activate. To prevent such an attack scheme, together with colleagues from the University of Pavia, we used a small BERT to capture all the nuances of the topics made available on a specific broker, e.g. all the measurements belonging to a set of IoT sensors grouped under the umbrella name IndustrialPlant/PowerGenerator. The model can then be used to fuzz-test detection metrics, defensive tools, or best practices used within an organisation to define naming conventions. Figure 2 depicts the proposed approach. Starting from real topics gathered “in the wild” the small BERT can produce “fake” but realistic topics to check the resilience of security policies against information hiding [3]. As an example, a properly trained SLM can automate the exploration of all the possible permutations used by an attacker to encode data (e.g. in the case-lowercase sequence of the letters composing a topic) or determine whether fake entries such as “IndustrialPlant/PowerGenerator” or “IndustrialPlant/PowerGenerator” are correctly handled at runtime.

The two results are the outcome of research activities carried out by a joint group of scientists from the Institute for High Performance Computing and Networking and the Institute for Applied Mathematics and Information Technologies, within the framework of the National Recovery and Resilience Plan [L1]. Our ongoing research aims at improving the overall security posture of modern software ecosystems when exposed

to MATE attacks, e.g. to prevent the abuse of digital images for cloaking malicious payloads or to protect software artifacts via watermarks.

This work was partially supported by project SERICS (PE00000014) under the MUR National Recovery and Resilience Plan funded by the European Union - NextGenerationEU.

**Link:**

[L1] https://serics.eu

**References:**

[1] J. Wang, L. Yu, and X. Luo, “LLMIF: augmented Large Language Model for fuzzing IoT devices,” in Proc. of the 2024 IEEE Symposium on Security and Privacy, pp. 196-209, San Francisco, CA, USA, 2024.

[2] F. Folino, et al., “Towards data- and compute-efficient fake-news detection: an approach combining active learning and pre-trained language models,” SN Computer Science, Vol. 5, pp. 470:1–470:18, 2024.

[3] C. Cespi Polisiani, et al., “Mitigation of covert communications in MQTT topics through small language models,” submitted to EuroCyberSec 2024 co-located with the 32nd International Symposium on the Modeling, Analysis, and Simulation of Computer and Telecommunication Systems, Krakow, Poland, 2024.

**Please contact:**

Gianluigi Folino, CNR-ICAR, Italy
gianluigi.folino@icar.cnr.it

# Strengthening Cyber Defence through Cooperative Development and Shared Expertise in Incident Response Playbooks

by Mehdi Akbari Gurabi, Lasse Nitz, Charukeshi Mayuresh Joglekar, and Avikarsha Mandal (Fraunhofer FIT)

**As cyberattacks evolve and become more complex, defenders require advanced tools for effective incident response. In the H2020 projects, SAPPAN and CyberSEAS, we conducted research to develop a cybersecurity playbook management system that provides a robust framework for creating, maintaining, and sharing standardised incident response procedures. The pilot validation shows how the system can be streamlined into current cybersecurity operations, towards compliance with the latest security recommendations and directives.**

In today's continuously evolving digital landscape, enhancing cybersecurity practices is more critical than ever. This dynamic environment necessitates a robust and adaptive ap-
<figure><img src="image_43.png" /><figcaption>Figure 1: Exemplary tool features in the UI include (top) a visual representation of the playbook in BPMN with an interactive modification option by clicking on the steps, and (bottom) an overview of the running step of a playbook with a command prompt for automatic execution or manual confirmation of action success.</figcaption></figure>

proach aligned with the cybersecurity recommendations and guidelines such as the National Institute of Standards and Technology (NIST) incident response life cycle. The relevance of standardised incident response procedures is amplified by the introduction of Collaborative Automated Course of Action Operations (CACAO), a new standard on how playbooks can be designed and shared. Additionally, the recent implementation of the Network and Information Security Directive (NIS2) aims to enhance cybersecurity measures across the European Union, broadening its scope to include more sectors and imposing stricter obligations. The NIS2 directive highlights the need for comprehensive and standardised incident response procedures to enhance the collaboration between stakeholders. The general nature of the directive requires specific tools that can effectively implement its guidelines.

Our playbook management tool SASP [1] aims to support the transition to NIS2 [2] by offering a structured and practical approach for collaborative incident response [3] and enabling standardised reporting. It provides a cooperative environment to enhance cybersecurity resilience through the cross-European exchange of expertise and experiences.

SASP research and development began with SAPPAN [L1], where we developed advanced cybersecurity solutions focused on privacy-preserving sharing of cybersecurity threats intelligence. SAPPAN focused on facilitating sharing and automation, utilising advanced data analysis and machine learning to enable efficient response and recovery. It supports both single and cross-organisational collaboration through privacy-preserving data processing and sharing, enriching situational awareness, facilitating intrusion detection, and enabling