The development of quantum computing poses a significant threat to currently deployed cryptographic primitives. To address this challenge, we design and implement a system to communicate and store data using post-quantum secure algorithms for a distributed blockchain environment. Specifically, we combine the Crystal-Dilithium digital signature scheme and an Updatable Encryption scheme based on the Learning With Errors problem in the context of a Hyperledger Fabric network. The Crystal-Dilithium scheme ensures authenticity and integrity of transmitted data, while the Updatable Encryption scheme provides confidentiality and integrity to transmitted data as well as allowing key rotation and ciphertext updates without requiring data re-encryption from scratch. An end-to-end prototype of the system is developed, including client-side modules, a Hyperledger Fabric gateway and smart contract modules that can be deployed on a Hyperledger Fabric network, with all components implemented in Python and Golang. The system is evaluated through functional integration tests and performance benchmarks. Results demonstrate that the Crystal-Dilithium scheme achieve sub-second execution for key generation, signing, and verification for multiple different parameter sets. For the Updatable Encryption scheme, encryption, decryption, and ciphertext updates exhibit linear scalability in time complexity with respect to the size and dimensions of input parameters, while token generation emerges as the most computationally demanding step in the algorithm. Additional experiments highlight the practical limits of repeated key rotations due to accumulated error growth.

Cybercrime is becoming increasingly sophisticated, creating major challenges for cybersecurity and, in particular, network forensics. Network forensics analysts play an essential role in detecting intrusions, investigating incidents, and preventing attacks through the analysis of network traffic. Yet the volume and complexity of network data, combined with the limits of current tools, make this work time-consuming and error-prone. This study addresses these challenges by designing and developing a prototype visualisation tool tailored to the needs of network forensics analysts. The research follows a structured four-phase methodology. First, interviews with professional analysts identify key tasks and challenges, forming the basis for the tool’s requirements. Second, the What-Why-How framework maps these tasks to appropriate visualisation techniques. Third, iterative prototyping translates these insights into an interactive prototype tool, refined through user feedback. Finally, an impact analysis assesses effectiveness, intuitiveness, and correctness by evaluating tasks performed by both experienced and inexperienced participants. The evaluation shows that the prototype significantly improves analysis workflows, lowering cognitive load, increasing efficiency, and reducing errors. Both experienced and inexperienced participants performed tasks faster using the prototype, demonstrating both accessibility and a reduced learning curve. The findings also highlight the value of a user-centred, task-oriented approach to visualisation design. This research contributes to network forensics by presenting a structured approach to developing domain-specific visualisation tools. The results highlight their potential to enhance the speed, accuracy, and reliability of analysis, strengthening cybersecurity as a whole.

Blockchain technology has significantly impacted digital transactions and data management by providing a decentralized, transparent, and immutable ledger. Private blockchains, unlike public blockchains, are restricted to a pre-selected group of participants, making them more suitable for controlled environments such as enterprises, governments, or academic institutions. Hyperledger Fabric (HLF) is a widely used framework for private blockchain technology, designed for enterprise use.

With quantum computers on the rise, commonly used cryptographic algorithms are increasingly at risk of becoming obsolete. Blockchain networks rely extensively on these primitives, making them particularly vulnerable to advances in quantum computing. To counter this vulnerability, post-quantum algorithms have gained popularity within the cryptographic community.

This thesis focuses on securing private blockchains built on HLF against potential quantum adversaries using post-quantum cryptographic primitives. We implement ML-DSA, Vesper, and TDUE as smart contracts for digital signing, zero-knowledge proofs, and updatable encryption, respectively, and report on their performance. Furthermore, we build on top of Fabric Private Chaincode to maintain the confidentiality of the contract application state. While overall performance is not yet competitive with classical cryptographic primitives, our findings indicate that post-quantum primitives have promising potential for use in private blockchains.

Organisations are increasingly adopting Microservice and Service-Oriented Architectures, moving from monolithic applications to (service-oriented) distributed systems. By their nature, distributed systems are prone to partial failures, where a subset of processes fail while others continue to operate. To assess the behaviour of the system when subjected to partial failures, we can inject faults that mimic partial failures. By automatically injecting all relevant combinations of faults, we can verify the system’s resilience or uncover resilience bugs. However, the search space consisting of all combinations of faults grows exponentially. Moreover, it requires significant engineering effort to adjust systems to work with existing state-of-the-art tools. This work investigates a practical approach to automated fault injection for service-oriented distributed systems while remaining efficient. We design a novel automated fault injection tool that uses network-level instrumentation to inject faults. By using an abstraction to model the system’s behaviour, we can dynamically infer information available to service-level instrumentation. Furthermore, we efficiently represent the search space as a search tree and prune it using multiple pruning policies. To evaluate our design, we developed an implementation of this design called Reynard. Compared to the current state-of-the-art, we show that Reynard is efficient, requiring equal or fewer states in the search space, has minimal overhead, and can be integrated into various existing benchmark systems with a feasible engineering effort. Furthermore, we demonstrate the applicability of Reynard by integrating it into an industry system, highlighting that it can run practical experiments and can identify real bugs. In conclusion, Reynard can provide a starting point for lowering the engineering effort required to perform automated fault injection testing, while increasing the confidence in the resiliency of systems.

The efficient rendering of scenes with many light sources remains one of the most challenging problems in real-time ray tracing. As the complexity of virtual environments continues to increase, with some scenes containing thousands of light sources, traditional Monte Carlo methods struggle to achieve acceptable noise levels under real-time constraints. This paper introduces a novel approach that combines Reservoir-based Spatiotemporal Importance Resampling (ReSTIR) with a specialised bounding volume hierarchy (BVH) structure to enhance light candidate generation for scenes with many light sources. The BVH-assisted candidate generation is tested on multiple scenes, resulting in a significant decrease in image noise levels measured with the root mean squared metric (RMSE), along with improved visual quality from the first frame onward, especially in scenes with numerous light sources illuminating local areas.

Blockchain technologies enable the decentralized storage and verification of records, such as financial transactions.
Systems like Bitcoin and Ethereum see a considerable usage and have market values in the order of 10s of billions of dollars.
A recent evolution of blockchain consensus systems, which have traditionally been maintaining a chain of blocks of transactions, is the introduction of Directed Acyclic Graph (DAG)-based algorithms.
In these new systems, popularized by companies such as Sui and IOTA, transactions are positioned in rows of blocks that are connected in a DAG.
The participants of these systems add blocks to the DAG in parallel, which has been shown to result in higher throughput, lower latency and higher decentralization.

Some blockchains, including DAG-based ones, support smart contracts, which enable the execution of (almost) arbitrary code with correctness, verifiability, and consistency guarantees.
A natural usage of smart contracts is Decentralized Finance (DeFi).
DeFi implements services that are offered in traditional centralized finance, such as loans and currency exchanges, in a decentralized fashion.
For example, instead of a central authority possessing different currencies and fixing their exchange rates through supply and demand of their clients, a decentralized exchange (DeX) can match buyers and sellers and update the exchange rate on the fly based on the supply of the two tokens.

The promise of safely removing the need for a central authority and regulations is however undermined by current blockchain implementations.
Intuitively, the decentralized nature of DeFi should prevent malicious behavior, but in practice validators (i.e., the entities that maintain the blockchain) have the possibility to do so.
For example, in Ethereum, miners have full control over the content of blocks.
This means that they have the power to reorder and inject transactions.
The profit that is obtained this way is called Miner Extractable Value (MEV).
% Indeed, the output of arbitrary code, in particular of DeFi code, can heavily depend on the transaction execution order.
% For example, in a DeX, if the exchange rate between two tokens is computed on the fly, an adversary can manipulate the transaction order to extract a profit.

MEV is not desirable because it introduces hidden costs for correct users: higher fees, worse exchange rates and network congestion.
Different mitigation techniques have been proposed over the years.
The most commonly used in practice are systems that allow the re-distribution or an easier extraction of MEV.
These have significant ethical concerns, as they increase resource consumption while still maintaining the negative side effects of MEV on the average consumer.

It is also possible to anonymize the content of transactions until after their execution, making it more difficult for attackers to exploit their contents for profit.
While anonymizing transactions makes an attacker's task more difficult, it requires the use of expensive cryptographic primitives or the presence of a trusted third-party, and transaction metadata might still be exploited to enable MEV.

The most interesting concept from the academic community against MEV is Order Fairness, which promises that transactions will be executed in an order that accurately represents the actual order in which the transactions were made public.
These systems have been mainly studied as an extension of existing linear consensus systems, but have been scarcely applied to DAGs.
Indeed, DAGs have been thought to have some inherent resistance to MEV extraction, but recent work by Zhang et al. has shown otherwise.

To the best of our knowledge, the only system that combines DAG-based consensus and Order Fairness is FairDAG.
While this protocol provides strong theoretical guarantees, we will show that it lacks real-world applicability and contains some suboptimal design decisions.

In this work we propose Tilikum, the first DAG-based consensus protocol that upholds Order Fairness through Ordering linearizability without sacrificing usability and improving average throughput by about 15 times.

Spectral Monte Carlo rendering stands as the gold standard for accurately simulating complex optical phenomena, such as fluorescence and chromatic dispersion, but typically exhibits slow convergence behavior due to challenges in sampling the wavelength domain. Convergence is even slower for scenes with complex spectral distributions, and hence a robust method for sampling the wavelength domain is crucial for better performance. To address this challenge, we propose a preprocessing step consisting of optimizing a set of distributions specifically for wavelength sampling, and we investigate whether this approach can achieve a lower perceptual error than traditional sampling techniques. Our evaluation indicates that our method can significantly reduce perceptual error in single-emitter scenes featuring a complex spectral power distribution (SPD), when compared to uniform sampling, without incurring any additional overhead during rendering.

Gaze estimation systems powered by deep neural networks are commonly used in sensitive applications such as driver assist or human-computer interaction. While backdoor attacks have been widely studied for classification tasks, vulnerability of regression networks like gaze estimators to these kind of attacks still remain underexplored. This research investigates the effectiveness of full-image backdoor attacks on appearance-based gaze estimation models. Specifically, the study explores dirty-label attacks with two types of global backdoor triggers: a spatial-domain sinusoidal pattern and a randomized frequency-domain perturbation. Experimental results on the MPIIFaceGaze dataset demonstrate that both triggers can reliably induce malicious outputs while preserving high accuracy on clean data, with the frequency-domain trigger offering superior stealth. These findings highlight a significant vulnerability in deep regression models, emphasizing the need for defensive mechanisms in real-world gaze estimation systems.

With the rise of AI, more attacks are targeted towards AI models. Trying to gain control over the output of the model. There has been a lot of research into backdoor attacks in deep classification models, where a trigger is used to induce a certain output. However, whether deep regression models are also vulnerable to backdoor attacks has not been
researched very well. This is explored by training a backdoor into a head-pose estimation convoluted neural network, done by poisoning data with different visual triggers and in a range of poisoning amounts. And tested by comparing the loss to a benign model. The results show a test loss of around 1.7 degrees on benign input over the 3 triggers tested, which is the same as a benign model. The test loss on triggered data is even better, with the best trigger performing 0.5 degrees. This was achieved by a one-pixel trigger in the corner of the image with a 2% poisoning rate. Thus, a back doored model is created that reacts to a visual trigger. Showing Deep regression models are vulnerable to backdoor attacks.

This thesis addresses the challenge of initial frame noise in real-time ray tracing when using ReSTIR. We propose and evaluate an approach that integrates a normal- aware hash grid for precomputed reservoir caching to improve direct illumination. The research investigates how reservoir caching enhances visual quality alongside ReSTIR and analyzes the associated trade-offs in memory usage and performance. Our con- tribution includes the implementation and analysis of this caching strategy, assessing its impact on visual fidelity across diverse scenes. Although the method significantly reduces noise and improves initial sampling convergence, it can introduce visible grid artifacts in scenes with many light overlaps. Furthermore, this approach incurs notable memory overhead and increased frame times. This work demonstrates the potential of normal-aware hash grids for ReSTIR improvements, providing a proof-of-concept algorithm for stable, high-quality initial samples.

Backdoor attacks manipulate the behaviour of deep neural networks through dataset poisoning, causing the models to produce specific outputs in the presence of a trigger, while behaving as expected otherwise. Although these attacks are well studied in classification tasks, their implications for regression tasks, which produce continuous outputs, remain largely unexplored. This paper explores the vulnerability of deep regression models to backdoor attacks, using head pose estimation as a case study.

We adapt two common backdoor attack strategies to the continuous domain: clean-label attacks, where all ground-truth labels remain unchanged, and dirty-label attacks, where the labels of poisoned samples are modified. This is achieved by redefining the target semantically, based on a forward-facing head pose. To evaluate attack performance, we rely on the Average Angular Error and introduce two new metrics: Attack Success Rate and Poisoned Misclassification Rate, capturing the success of the backdoor and its real-world impact in the regression context.

Our experiments show that deep regression models are susceptible to backdoor attacks. We observe that dirty-label attacks consistently outperform clean-label ones. Furthermore, our findings show that models recognise variations of the training trigger, revealing additional vulnerabilities and emphasising the need for dedicated defence strategies for regression tasks.

In this paper, we propose techniques to increase the effective resolution of a pathtracer without changing the resolution of the screen for which it is rendered. These make use of the fact that displays are made up of pixels, each of which is made up of three distinct subpixels. By setting luminance values for subpixels rather than colour values for a full pixel, we can create a higher fidelity image. This is already used in rendering text, but has not yet been applied to a pathtracer. It is done in three distinct ways; firstly we send three rays per pixel, each centred at a subpixel to obtain a value for every subpixel, the second method is using a filter used for downscaling text. Lastly, we implement a technique that makes use of the aforementioned filter without increasing the number of samples needed. By sampling a random subpixels each frame for each pixel and combining neighbouring pixels proportional to the filter. We find that these methods are quite effective at the goal of increasing perceived resolution in high-contrast scenes.

Unit test case generation aims to help software developers test programmes. The evolutionary algorithm is one of the successful approaches for unit test case generation that evolves problem solutions over time. Previous research on seeding, the use of previously available information to improve search performance, showed positive improvements in unit test case generation. However, this approach cannot be used in the absence of previously available information, such as existing unit test cases.

The recent increased availability of Large Language Models (LLMs), which were trained on various corpora of previously available data, provides an opportunity to address the seed absence problem. We devised an approach involving TestSpark and EvoSuite to see the impact of LLM-based seeding on unit test case generation. TestSpark, an IntelliJ plugin, uses ChatGPT-4o to generate test cases which we later supply as a seed for EvoSuite's seeding strategies such as cloning and carving. We evaluated our approach on a set of 136 Java 11 projects from the GitBug-Java dataset w.r.t. line coverage, branch coverage, mutation score, and area under the curve.

Our results show that LLM-based seeding has the potential to improve EvoSuite's unit test case generation if it manages to extract information from the seed. Our approach experiences significant struggles to supply LLM-generated tests from which information can be extracted. We lost 63% of the benchmark classes because LLM did not generate functional tests for all experiment iterations. Meanwhile, another 24% of the benchmarks are excluded because EvoSuite seeding does not extract any information from them.

Deep learning sustained great success in several domains, particularly in computer vision, where it facilitates tasks such as image classification and object recognition. However, one significant challenge in deep learning is data labeling, due to the high cost and effort required for human annotators to go over this process manually. Active learning addresses this problem by selecting a smaller amount of the most relevant data for this labeling process, maximizing efficiency. Despite its advantages, active learning presents new security threats. In particular, backdoor attacks, where adversaries poison part of the training data to modify the behavior of the model in the presence of a hidden trigger. Although backdoor attacks have been extensively studied in traditional deep learning contexts, their impact on active learning remains largely uncertain.

Here, the vulnerabilities of active learning against backdoor attacks in computer vision models were analyzed. Various configurations, datasets and deep learning models were used to evaluate their effectiveness. Backdoor attacks managed to hit ASR values over 95% with just 1% of the data being poisoned on simple datasets like MNIST, particularly when using certainty-based sampling and CNNs. More complex datasets like CIFAR-10 and models like ResNet proved to be more resilient. Furthermore, different attack techniques were explored, such as progressive parameter adjustment, sub-trigger division and clean label attacks on advanced backdoor triggers like LIRA and WaNet. The analysis revealed that although global LIRA triggers were the most effective, sub-trigger and progressive poisoning methods offered promising alternatives, especially because they allow poisoning smaller parts of images across training cycles. Additionally, it is revealed that attack success in clean-label scenarios was highly dependent on the number of poisoned samples per cycle, due to the post-query constraint that only allows poisoning already-selected samples, often limiting impact when the target label appears infrequently. Finally, different poisoning timings were compared. From this, post-query poisoning consistently outperformed pre-query methods in terms of ASR, even at low poison rates. However, it also pointed out that this approach has its limitations in real-world scenarios, where attackers usually do not have control over the samples being queried. Clean accuracy remained unaltered to a large extent, demonstrating the stealth and hidden threat of backdoor attacks in active learning settings.

In this work, we propose a general solution to address the non-IID challenges that hinder many defense methods against backdoor attacks in federated learning. Backdoor attacks involve malicious clients attempting to poison the global model. While many defense methods effectively filter out these malicious clients using clustering techniques, their effectiveness diminishes when the federated learning process involves non-IID datasets. In such cases, clustering methods struggle to distinguish between benign and malicious clients due to the inherent variability in the clients' data distributions.
Our proposed solution leverages data generation to mitigate the non-IID nature of clients' local datasets. By generating synthetic data, the datasets become more IID, enabling defense methods to once again effectively counter backdoor attacks. Evaluations are carried out on standard datasets in the image classification fields, like MNIST and CIFAR-10. The results show that the data generation solution can effectively improve the performance of defense methods and filter out malicious clients again. Although the generated data samples may suffer from low quality and limited diversity due to constraints in training the generative adversarial networks (GANs), our approach demonstrates significant improvements in defending against backdoors.

The rise of the Internet of Things (IoT) has introduced levels of convenience never seen before, but also presents a significant cybersecurity challenge. Especially the insecure nature of many of these IoT devices fuels the emergence of advanced IoT botnets. The Gorilla botnet is a potent example of such IoT botnets and took the internet by surprise in September 2024. That month alone, Gorilla has been responsible for over 300,000 Distributed Denial-of-Service (DDoS) attacks across 100 countries. Although inspired by earlier botnets like Mirai and Gafgyt, Gorilla exhibits unique characteristics and attack strategies that remain largely unexplored.

This thesis conducts a detailed analysis of the Gorilla botnet, focusing on its communication patterns, infection strategies, and attack behaviors. By executing Gorilla’s malware samples in a controlled environment, the study captures insights into its command-and-control (C2) communication and attack strategies. Key findings include the identification of a flaw in Gorilla’s implementation, which could aid future detection efforts, and the discovery of its preference for UDP-based attacks targeting gaming-related services.

Through this work, we contribute a dataset and analysis framework that sheds light on Gorilla’s operations, highlighting its similarities to and deviations from the original Mirai botnet. The findings provide insightful observations, enabling improvements in defenses against IoT botnet threats.

This work explores the feasibility of combining zero-knowledge proofs with SGX enclave protection technology, using the Hyperledger fabric, as the testing environment. The focus is on assessing the viability of this combination in real-world scenarios where post-quantum security is crucial. To this end, a new zero-knowledge proof, called Vesper, has been developed. This is a lattice-based zk-SNARK with a Regev commitment scheme. Vesper aims to provide a novel approach to developing lattice-based zero-knowledge proofs suitable for blockchain environments. Vesper features a proof size of 128 bytes, an average verification time of 0.14 ms, requires no trusted setup, while achieving at least 128-bit and 256-bit security. Only the proof geberation time increases when the LWE dimension increases. To analyze and explore the potential of combining Intel SGX with such a ZKP and Hyperledger Fabric, two projects have been developed: 1. Vesper Smart Contract: This project uses Vesper in combination with a lattice-based digital signing scheme that has been NIST-approved. The proof generation benefits from SGX enclave protection, while the verifier for Vesper is deployed in a permissioned blockchain as a smart contract. Middleware using Fabric Peer command line interface (CLI) tools facilitates commu- nication between the prover and verifier sides. 2. Vesper-FPC: This project explores the feasibility of protecting Hyperledger Fabric chaincode with an SGX enclave. It combines Vesper with a simplified lattice-based digital signing function to accommodate a restricted environment. Both the proof generation and the deployed verifier are SGX-protected. Communication is managed via custom peer CLI commands specifically de- signed to handle the interaction between the additional SGX protection layer and the blockchain infrastructure. The simplified digital signing scheme of Vesper-FPC has a fast average verification time of 1.46 ms and an even faster average signing time of 0.49 ms while achiving 128-bit security. This is quicker than the NIST-approved digital signing scheme of Vesper Smart Contract, which has average signing and verification times of approximately 76.52 ms and 13.25 ms, respectively. The simplified version features a private key size of 512 bytes, a signature size of 768 bytes, and a public key size of 48 KB. In contrast, the digital signing scheme of Vesper Smart Contract has a private key size of 2528 bytes, a signature size of 2420 bytes, and a public key size of 1312 bytes. The execution time of Vesper Smart Contract without SGX is on average approximately 2086.83 ms for a 128-bit security level. Adding SGX protection on the prover side increased the average execution time to 26339 ms. Vesper-FPC, with SGX protection for both the prover and the deployed verifier, has an average execution time of approximately 51229 ms.

Cyber attacks have become increasingly more prominent and the associated cost to society is by several estimates reaching trillions of US dollars. A typical cyber attack goes
through the several consecutive phases of the cyber kill chain. As a precursor for any attack, the malicious actor performs network reconnaissance in order to identify potential
entry points through exploitable services connected to the internet. Therefore, early detection of reconnaissance by scanners can mitigate or entirely prevent future attacks. Modern
intrusion detection systems are capable of blocking some scan attempts. However, more sophisticated and resourceful attackers are suspected to distribute their efforts over a large number of sources. This allows them to lower the individual scanrate while achieving the same throughput. Slow scanners are harder to detect, because they differentiate little from baseline noise levels. Additionally, a threat is severely underestimated if a large number collaborating scanners is not treated as a single entity. Therefore, the aim of this thesis is to infer such a coordinated relationship between scanners controlled by a single initiator.

We analyse the data from a network telescope with an observation of one year, much longer than previous work. Initial analysis led to the discovery of similar long-term activity patterns present in distributed scanners. These patterns can be used to uniquely identify a group which formed the basis for the correlation algorithm. We were successfully able to detect a large number of clusters employing various strategies in terms of size, scanrate and targeted services. Due to the absence of ground truth additional effort has been spent to validate potential clusters through other characteristics. We also demonstrate the utility of transforming the raw telescope data for cluster analysis through a case study of very slow scanners.

The increasing number of malicious packages being deployed in open source package repositories like PyPI or npm prompted numerous works aiming to secure open source ecosys- tems. The increased availability and deployment of safeguards raises the question whether and how attackers evolved their tactics and techniques, and the possibility of improving the current detection methods.
In order to improve detection, an important step is to understand how attackers design malicious packages and if it has evolved over time as detection methods improved. We conducted a semi-automated analysis and labeling of approx. 4000 malicious packages in order (a) to identify and quantify the techniques used by malware authors, (b) to uncover malware campaigns through clustering the CodeBERT embeddings of malicious code, and (c) to contrast the results with previous studies.
To detect malicious packages, existing work all rely on a common classification pipeline: first a human-defined rule-based feature extraction mechanism then a trained classifier. We hypothesize that the feature extraction mechanism is a limiting factor to classifier perfor- mance, and an additional step that needs to be kept up to date. To address this problem, multiple models utilizing the freshly labeled dataset were trained and compared: 2 types of fine tuned CodeBERT models, 2 isolation forest models and 1 out of distribution model.
We learned that the number of attacks on legitimate packages dropped in comparison to name confusion attacks, e.g. typo-squatting or dependency confusion, which are conducted with increasing campaign sizes. At the same time, packages are taken down more swiftly, whereas the characteristics of the malicious code itself did not substantially change. There are shifts in regards to the use of obfuscation or the primary objective, but the malicious code stays generally very simple.
We found that CodeBERT fine tuned with a loss function utilizing the equivalent of scikit-learn’s 𝑐𝑙𝑎𝑠𝑠_𝑤𝑒𝑖𝑔h𝑡 =′ 𝑏𝑎𝑙𝑎𝑛𝑐𝑒𝑑′ equation (Bert-Balanced) performed best with a specificity of 98.2% and recall of 93.7%. In the real world scenario, we evaluated a total of 8734 unique packages in the updates feed and 2181 in the new packages feed, and found 4 unique malicious packages. Bert-Balanced was able to keep up with the volume of packages being uploaded to PyPI, with plenty of computational resources still available.