Analyzing the Impact of Feature Changes in Linux - Ziegler, Andreas; Rothberg, Valentin; Lohmann, Daniel (Proceedings of the Tenth International Workshop on Variability Modelling of Software-intensive Systems, 2016)
In a software project as large and as rapidly evolving as the Linux kernel, automated testing systems are an integral component to the development process. Extensive build and regression tests can catch potential problems in changes before they appear in a stable release. Current systems, however, do not systematically incorporate the configuration system Kconfig. In this work, we present an approach to identify relationships between configuration options. These relationships allow us to find source files which might be affected by a change to a configuration option and hence require retesting. Our findings show that the majority of configuration options only affects few files, while very few options influence almost all files in the code base. We further observe that developers sometimes value usability over clean dependency modelling, leading to counterintuitive outliers in our results.<br
UnivIS-Import:2017-12-18:Pub.2016.tech.IMMD.IMMD4.analyz
Keywords: CADOS; Linux

Attack Surface Metrics and Automated Compile-Time OS Kernel Tailoring - Kurmus, Anil; Tartler, Reinhard; Dorneanu, Daniela; Heinloth, Bernhard; Rothberg, Valentin; Ruprecht, Andreas; Schröder-Preikschat, Wolfgang; Lohmann, Daniel; Kapitza, Rüdiger (Proceedings of the 20th Network and Distributed System Security Symposium (NDSS '13), 2013)
UnivIS-Import:2015-04-16:Pub.2013.tech.IMMD.IMMD4.attack
Keywords: VAMOS; Configurability; System Software; Software Engineering; Maintenance; Security

Automatic OS Kernel TCB Reduction by Leveraging Compile-Time Configurability - Tartler, Reinhard; Kurmus, Anil; Heinloth, Bernhard; Rothberg, Valentin; Ruprecht, Andreas; Dorneanu, Daniela; Kapitza, Rüdiger; Schröder-Preikschat, Wolfgang; Lohmann, Daniel (Proceedings of the 8th Workshop on Hot Topics in System Dependability (HotDep '12), 2012)
The Linux kernel can be a threat to the dependability of systems because of its sheer size. A simple approach to produce smaller kernels is to manually configure the Linux kernel. However, the more than 11000 configuration options available in recent Linux versions render this a demanding task. We report on designing and implementing the first automated generation of a workload-tailored kernel configuration and discuss the security gains such an approach offers in terms of reduction of the Trusted Computing Base (TCB) size. Our results show that the approach prevents the inclusion of 10% of functions known to be vulnerable in the past.<br
UnivIS-Import:2015-04-16:Pub.2012.tech.IMMD.IMMD4.automa_0
Keywords: VAMOS; Configurability; System Software; Software Engineering; Maintenance; Security

cHash: Detection of Redundant Compilations via AST Hashing - Dietrich, Christian; Rothberg, Valentin; Füracker, Ludwig; Ziegler, Andreas; Lohmann, Daniel (Proceedings of the 2017 USENIX Annual Technical Conference (ATC '17), 2017)
UnivIS-Import:2017-12-18:Pub.2017.tech.IMMD.IMMD4.chashd
Keywords: Compiler; Optimization; CADOS

Feature Models in Linux - From Symbols to Semantic - Rothberg, Valentin; Dintzner, Nicolas; Ziegler, Andreas; Lohmann, Daniel (Proceedings of the Tenth International Workshop on Variability Modelling of Software-intensive Systems, 2016)
Linux is a highly configurable operating-system kernel which has been widely studied in the context of software product lines over the past years. Understanding the challenges and perils of evolving and maintaining feature models of the size of Linux is crucial to provide the right tools for development today and to direct future research. Unfortunately, previous studies show contradictory observations when analyzing the evolution of Linux feature models. We explain how peculiarities of the feature models of the Linux kernel lead to those differing observations, and show how the results can be re-aligned. Moreover, our findings also demonstrate that symbolic differencing on feature models used by researchers so far has limited value, depending on the use case. We show how the limitations can be addressed by means of semantic differencing, and ironically invalidate the results we sought to re-align.<br
UnivIS-Import:2017-12-18:Pub.2016.tech.IMMD.IMMD4.featur
Keywords: CADOS; Linux

Honey, I Shrunk the ELFs: Lightweight Binary Tailoring of Shared Libraries - Ziegler, Andreas; Geus, Julian; Heinloth, Bernhard; Hönig, Timo; Lohmann, Daniel (Transactions on Embedded Computing Systems, 2019)
In the embedded domain, industrial sectors (i.e., automotive industry, avionics) are undergoing radical changes. They broadly adopt commodity hardware and move away from special-purpose control units. During this transition, heterogeneous software components are consolidated to run on commodity operating systems. To efficiently consolidate such components, a modular encapsulation of common functionality into reusable binary files (i.e., shared libraries) is essential. However, shared libraries are often unnecessarily large as they entail a lot of generic functionality that is not required in a narrowly defined scenario. As the source code of proprietary components is often unavailable and the industry is heading towards binary-only distribution, we propose an approach towards lightweight binary tailoring. As demonstrated in the evaluation, lightweight binary tailoring effectively reduces the amount of code in all shared libraries on a Linux-based system by 63 percent and shrinks their files by 17 percent. The reduction in size is beneficial to cut down costs (e.g., lower storage and memory footprint) and eases code analyses that are necessary for code audits.
CRIS-Team Scopus Importer:2019-10-22
Keywords: Binary tailoring; Linux; Shared libraries

Thread-Level Attack-Surface Reduction - Rommel, Florian; Dietrich, Christian; Ziegler, Andreas; Ostapyshyn, Illia; Lohmann, Daniel (Proceedings of the ACM SIGPLAN Conference on Languages, Compilers, and Tools for Embedded Systems (LCTES), 2023)
Existing debloating techniques designed to prevent buffer-overflow exploits through return-oriented programming do not differentiate roles within a process or binary, allowing all threads access to the full program functionality. For example, a worker thread that handles client connections (highest attack exposure) still has access to all the code that the management thread needs (highest potential fallout). We introduce thread-level attack-surface reduction (TLASR), a dynamic, context-aware approach that eliminates unused code on a thread level. For this, we (permanently or temporarily) eliminate parts of the text segment (both in shared libraries and the main binary) and use the mmview Linux extension to support multiple text-segment views in a single process. We reduce the executable code visible from a single thread in MariaDB, Memcached, OpenSSH, and Bash by 84 to 98.4 percent. As a result, the number of ROP gadgets decreases significantly (78–97 %), with TLASR rendering an auto-ROP utility ineffective in all investigated benchmarks and eliminating all CVE-related functions ever reported for glibc in 97 percent of the cases.
CRIS-Team Scopus Importer:2023-07-21
Keywords: binary tailoring; debloating; return-oriented programming

Towards Scalable Configuration Testing in Variable Software - Rothberg, Valentin; Dietrich, Christian; Ziegler, Andreas; Lohmann, Daniel (Proceedings of the 2016 International Conference on Generative Programming: Concepts and Experiences, 2016)
Testing a software product line such as Linux implies building the source with different configurations. Manual approaches to generate configurations that enable code of interest are doomed to fail due to the high amount of variation points distributed over the feature model, the build system and the source code. Research has proposed various approaches to generate covering configurations, but the algorithms show many drawbacks related to run-time, exhaustiveness and the amount of generated configurations. Hence, analyzing an entire Linux source can yield more than 30 thousand configurations and thereby exceeds the limited budget and resources for build testing. In this paper, we present an approach to fill the gap between a systematic generation of configurations and the necessity to fully build software in order to test it. By merging previously generated configurations, we reduce the number of necessary builds and enable global variability-aware testing. We reduce the problem of merging configurations to finding maximum cliques in a graph. We evaluate the approach on the Linux kernel, compare the results to common practices in industry, and show that our implementation scales even when facing graphs with millions of edge
UnivIS-Import:2017-12-18:Pub.2016.tech.IMMD.IMMD4.toward
Keywords: Configurability; Linux; Sampling; Software product lines; Software testing