Attribut:Kurzfassung
Dies ist ein Attribut des Datentyps Text.
I
Moderne Softwaresysteme müssen einer Vielzahl von Sicherheitsanforderungen gerecht werden. Diese Anforderungen scheinen im Laufe der Zeit immer strenger zu werden. Heutzutage führt ein Softwaresystem, das Vertraulichkeitsanforderungen nicht erfüllt, oft zur unbeabsichtigten Offenlegung sensibler Daten. Dies ist oft mit finanziellen Kosten verbunden, da die DSGVO Bußgelder eingeführt und erhöht hat, kann aber auch den Ruf eines Unternehmens beeinträchtigen und zu Kundenverlusten führen. Viele Sicherheitslücken können aus Diskrepanzen zwischen der Architekturplanung und der Implementierung des Codes entstehen. Aus diesem Grund untersucht diese Arbeit die Integration einer statischen, architekturbasierten Vertraulichkeitsanalyse mit einer statischen, codebasierten Informationsflussanalyse. Durch die Kombination dieser beiden Analysen möchten wir zeigen, dass wir eine Diskrepanz zwischen Design und Implementierung identifizieren können. Der in dieser Arbeit gewählte Ansatz behandelt die Architekturplanung als das beabsichtigte Verhalten des Systems. Es werden die erforderlichen Artefakte generiert, um eine codebasierte Analyse durchzuführen und zu überprüfen, ob die auf der Architektur definierten Eigenschaften auf die Implementierung anwendbar sind. In einer kleinen Studie haben wir die Durchführbarkeit des Ansatzes evaluiert. Zusammenfassend zielt diese Arbeit darauf ab, die Lücke zwischen der architekturellen Sicht und der Codesicht zu überbrücken, indem Vertraulichkeitseigenschaften in beiden verbunden werden. +
Monitoring of time series data is increasingly important due to massive data generated by complex systems, such as industrial production lines, meteorological sensor networks, or cloud computing centers. Typical time series monitoring tasks include: future value forecasting, detecting of outliers or computing the dependencies.
However, the already existing methods for time series monitoring tend to ignore the background information such as relationships between components or process structure that is available for almost any complex system. Such background information gives a context to the time series data, and can potentially improve the performance of time series monitoring tasks.
In this bachelor thesis, we show how to incorporate structured background information to improve three different time series monitoring tasks. We perform the experiments on the data from the cloud computing center, where we extract background information from system traces. Additionally, we investigate different representations and quality of background information and conclude that its usefulness is independent from a concrete time series monitoring task. +
Cloud systems may consist of collections of smaller software components (in some cases called microservices), possibly written in different programming languages and hosted across various hardware nodes. These components require continuous adaptation to changing workload and privacy constraints. There exist approaches solving this problem already, but they come along with limitations including binding to a certain platform or programming languages and not accurate handling of multi-host applications.
This thesis presents an approach to platform-independent observing of cloud applications, including comprehensive monitoring of relationships between components of the system. The concept of a time series database is used under the hood for storing monitoring data. It gets then transformed into the format needed for the performance model extraction.
Furthermore, a complete specific implementation of the approach with exemplary tools is provided. +
Realizing complex software projects is often done by utilizing multiple programming or modelling languages. Separate parts of the software are relevant to certain development tasks or roles and differ in their representation. These separate representations are related and contain redundant information. Such redundancies exist for example with an implementation class for a component description, which has to implement methods with signatures as specified by the component. Whenever redundant information is affected in a development update, other representations that contain redundant information have to be updated as well. This additional development effort is required to keep the redundant information consistent and can be costly.
Consistency preservation languages can be used to describe how consistency of representations can be preserved, so that in use with further development tools the process of updating redundant information is automated. However, such languages vary in their abstraction level and expressiveness. Consistency preservation languages with higher abstraction specify what elements of representations are considered consistent in a declarative manner. A language with less abstraction concerns how consistency is preserved after an update using imperative instructions. A common trade-off in the decision for selecting a fitting language is between expressiveness and abstraction. Higher abstraction on the one hand implies less specification effort, on the other hand it is restricted in expressiveness compared to a more specific language.
In this thesis we present a concept for combining two consistency specification languages of different abstraction levels. Imperative constructs of a less abstract language are derived from declarative consistency expressions of a language of higher abstraction and combined with additional imperative constructs integrated into the combined language. The combined language grants the benefits of the more abstract language and enables realizing parts of the specification without being restricted in expressiveness. As a consequence a developer profits from the advantages of both languages, as previously a specification that can not be completely expressed with the more abstract language has to be realized entirely with the less abstract language.
We realize the concepts by combining the Reactions and Mappings language of the VITRUVIUS project. The imperative Reactions language enables developers to specify
triggers for certain model changes and repair logic. As a more abstract language, Mappings specify consistency with a declarative description between elements of two representations and what conditions for the specific elements have to apply. We research the limits of expressiveness of the declarative description and depict, how scenarios are supported that require complex consistency specifications. An evaluation with a case study shows the applicability of the approach, because an existing project, prior using the Reactions language, can be realized with the combination concept. Furthermore, the compactness of the preservation specification is increased.
The increasing number of computer science students has prompted educators to rely on state-of-the-art source code plagiarism detection tools to deter the submission of plagiarized coding assignments. While these token-based plagiarism detectors are inherently resilient against simple obfuscation attempts, recent research has shown that obfuscation tools empower students to easily modify their submissions, thus evading detection. These tools automatically use dead code insertion and statement reordering to avoid discovery. The emergence of ChatGPT has further raised concerns about its obfuscation capabilities and the need for effective mitigation strategies.
Existing defence mechanisms against obfuscation attempts are often limited by their specificity to certain attacks or dependence on programming languages, requiring tedious and error-prone reimplementation. In response to this challenge, this thesis introduces a novel defence mechanism against automatic obfuscation attacks called match merging. It leverages the fact that obfuscation attacks change the token sequence to split up matches between two submissions so that the plagiarism detector discards the broken matches. Match merging reverts the effects of these attacks by intelligently merging neighboring matches based on a heuristic designed to minimize false positives.
Our method’s resilience against classic obfuscation attacks is demonstrated through evaluations on diverse real-world datasets, including undergrad assignments and competitive coding challenges, across six different attack scenarios. Moreover, it significantly improves detection performance against AI-based obfuscation. What sets our method apart is its language- and attack-independence while its minimal runtime overhead makes it seamlessly compatible with other defence mechanisms. +
Correlation analysis aims at discovering and summarizing the relationship between the attributes of a data set. For example, in financial markets, the price of stocks evolves over time. Via a careful estimation of the relationship between stocks, one can try to predict which stock to buy or sell to maximize the wealth of a portfolio.
The standard tool of correlation analysis is the computation of a correlation matrix. However, in the case of streams with many dimensions, it is difficult to extract actionable insights from the correlation matrix, as the number of pairs of attributes increases quadratically and the coefficients evolve over time in unforeseen ways. Thus, novel visualization methods are required.
In this thesis, we will investigate how to visualize the evolution of correlation in high-dimensional data streams in an intuitive way. We will, for example, discuss visualization methods based on force-directed graphs. Also, we will develop a web interface to visualize the correlation structure of data streams and evaluate it systematically via user studies. +
Investigating Variational Autoencoders and Mixture Density Recurrent Neural Networks for Code Coverage Maximization +
Graphical User Interfaces (GUIs) are a common interface to control software. Testing the graphical elements of GUIs is time-consuming for a human tester because it requires interacting with each element, in each possible state that the GUI can be in. Instead, automated approaches are desired, but they often require many interactions with the software to improve their method. For computationally-intensive tasks, this can become infeasible. In this thesis, I investigate the usage of a reinforcement learning (RL) framework for the task of automatically maximizing the code coverage of desktop GUI software using mouse clicks. The framework leverages two neural networks to construct a simulation of the software. An additional third neural network controls the software and is trained on the simulation. This avoids the possibly costly interactions with the actual software. Further, to evaluate the approach, I developed a desktop GUI software on which the trained networks try to maximize the code coverage. The results show that the approach achieves a higher coverage compared to a random tester when considering a limited amount of interactions. However, for longer interaction sequences, it stagnates, while the random tester increases the coverage further, and surpasses the investigated approach. Still, in comparison, both do not reach a high coverage percentage. Only random testers, that use a list of clickable widgets for the interaction selection, achieved values of over 90% in my evaluation. +
A main issue of using performance models, is the effort it takes to keep them updated. They must stay in synchronization with the actual system architecture and source code, in order to produce meaningful results. To address this shortcoming, there exist techniques, which extract the structure of a system and derive a performance model from existing artifacts, for example, from source code. Existing approaches estimate performance model parameters like loop iterations, branch transitions, resource demands and external call arguments for a whole system at once. We present an approach which estimates parameters of such performance models iteratively. We use monitoring data to estimate performance model parameters which are affected by an iterative source code change. We use a decision tree to build a predictive model for branch transitions and regression analysis to build a predictive model for loop iterations and resource demands. These predictive models can include dependency relations to service call arguments. To estimate resource demands iteratively, we must know all resource demands that are executed in a system. We monitor only a part of a system during one iteration and must estimate which resource demands are executed, but not monitored. We use the previously estimated performance model parameters and the control flow information of services to traverse the control flow in order to detect non-monitored resource demands. +
Iterative Quelltextanalyse für Informationsflusssicherheit zur Überprüfung von Vertraulichkeit auf Architekturebene +
Kurzfassung +
K
Especially in large software systems there are cases where only a subset of the dependents of a component needs to be built in order to produce sound build results for a certain change scenario; in the context of this work, this is called a build shortcut. The utilization of build shortcuts shortens build times, as the rebuilding of unafected parts is avoided. This thesis is concerned with the question of how the benefts of build shortcuts can be made accessible to a whole team of developers where not every member is a build expert. Our approach is to model the change specifc dependencies in a Palladio Component Model and determine the components to be built for a given change with the change propagation algorithm of the KAMP approach, posing as an example to integrate it into an agile development process. +
Das Ziel dieser Thesis ist es, ein Lösungskonzept zu entwickeln, das die Koevolution von MOF-basierten Metamodellen und Metamodellinstanzen automatisiert und vereinfacht. Dies wird dadurch erreicht, dass zunächst die Erfassung der Änderungen analysiert und für die Anwendung auf eine Metamodellvariante ausgebaut wird. Das erarbeitete Konzept erlaubt es, Änderungen an einem Metamodell automatisch in einer historisch verwandten Metamodellvariante nachzuspielen. Soll dagegen eine Änderung nur an der aktuellen Metamodellvariante stattfinden, so wird automatisch eine Transformationsregel basierend auf der gleichen Änderungsaufzeichnung erzeugt. In dem ersten Fall, der Koevolution auf Metamodellebene, wird prototypisch eine Heuristik realisiert, die im Erfolgsfall eine Übereinstimmung eines Artefakts in zwei Metamodellvarianten vorfindet.
Mit den Konzepten und Verfahrensweisen lassen sich weitere Heuristiken entwerfen mit dem Ziel, die Fehleranfälligkeit von manuellen Übertragungen der Änderungen zu reduzieren und die Weiterentwicklung der Metamodelle und Metamodellinstanzen zu erleichtern. +
Unser heutiges Leben wird zunehmend von Assistenzsystemen erleichtert. Hierzu gehören auch die immer häufiger verwendeten intelligenten Sprachassistenten wie Apple's Siri. Statt lästigem Flüge vergleichen auf diversen Internetportalen können Sprachassistenten dieselbe Arbeit tun.
Um Informationen verarbeiten und an den passenden Webdienst weiterleiten zu können, muss das Assistenzsystem natürliche Sprache verstehen und formal repräsentieren können. Hierfür werden bei Siri aktive Ontologien (AOs) verwendet, die derzeit mit großem manuellem Aufwand manuell erstell werden müssen.
Die am KIT entwickelte Rahmenarchitektur EASIER beschäftigt sich mit der automatischen Generierung von aktiven Ontologien aus Webformularen.
Eine Herausforderung bei der Erstellung von AOs aus Webformularen ist die Zuordnung unterschiedlich ausgeprägter Formularelemente mit gleicher Semantik, da semantisch gleiche aber unterschiedlich realisierte Konzepte zu einem AO-Knoten zusammengefasst werden sollen. Es ist daher nötig, semantisch ähnliche Formularelemente identifizieren zu können.
Diese Arbeit beschäftigt sich mit der automatischen Identifikation solcher Ähnlichkeiten und der Konstruktion von Abbildungen zwischen Formularelementen. +
Als Projektpartner im DAM4KMU-Projekt entwickelt das Forschungszentrum für Informatik (FZI) einen Demonstrator und legt besonderen Fokus auf die Erforschung kontextsensitiver Assistenzmethoden. Diese Arbeit soll zu dieser Forschung beitragen und sich besonders mit der Verknüpfung der Anforderungen beschäftigen. Es soll aus den Anforderungsdokumenten eine Komponentenhierarchie extrahiert werden und jeder Komponente sollen die für sie relevanten Anforderungen zugeordnet werden. Hierzu wurden verschiedene Klassifikatoren trainiert und evaluiert, um Anforderungen in Anforderungsdokumenten zu ermitteln. Weiterhin wurde eine Extraktion von Komponenten entwickelt.
Die Ergebnisse sind insgesamt durchwachsen, da die Datenmenge eher klein ist und Anforderungen sehr divers formuliert sein können. +
Das Erstellen von Trace-Links die beispielsweise Dokumentation mit Entwurfsmodellen verknüpfen ist ein wertvoller Bestandteil der Softwareentwicklung. Da ein manuelles Herauslesen der Trace-Links oft nicht praktikabel ist, sollte dieser Prozess automatisiert werden. Es existieren schon viele verschiedene Ansätze der Trace-Link-Recovery, welche jedoch unterschiedliche Stärken und schwächen haben. In dieser Arbeit wird untersucht, ob die Stärken unterschiedlicher Recovery-Ansätze durch Komposition verknüpft werden können, um ggf. die Schwächen auszugleichen. Dazu habe ich mehrere einfache Kompositionen implementiert und deren Ergebnisse ausgewertet. Dazu wird Ausbeute, Präzision, F1 und F2 verschiedener Kompositionen in drei Fallstudien ermittelt und mit denen der Basis-Ansätze verglichen. +
As there are many modeling methods of systems, there is always when designing a new system the problem which modeling method to use. The reason is that every modeling method designs the system from a specific viewpoint. However, all of these viewpoints are usually needed together in order to better design a system. It is also time costing to repeat integrating same information in every modeling method in order to be capable of analyzing the system from its viewpoint. In recent years, approaches to combine different modeling viewpoints together in a new modeling method or transforming one modeling method to another has been increasing. Especially there is a great focus on the relation between the data flow modeling and the control flow modeling as both of them are essential to design a good analyzed system. While the data-oriented descriptions are important for the architects to know about the flow of the data in the system and the data dependencies between the different components, they don't allow them to widely analyze the performance of the system as the control-flow-oriented ones do. On the other hand for some properties of the system, the analysis does not require a fine-grained description of the internal detailed behavior of system components which is offered by the control flow modeling. Our goal in this thesis is to deal with these both different available modeling methods of systems. We assume that we are already using data flow modeling to describe our desired system and that we want to further analyze the performance of the system and its control flow. We go through transforming the available data flow model (DFM) to a control flow model (CFM) stub containing all of the available information in the DFM, which can be then simulated with as few modifications. We define some conditions, which we consider that they must exist in the transformation process between DFMs and CFMs in order to be meaningful and valid. Based on these conditions we create mapping rules which maps the available elements in the DFM to their suitable patterns in the Palladio Component Model (PCM), which is a control-flow oriented description language, maintaining all information which is introduced in the DFM. We evaluate our work by going through the elements of the PCM, classifying them and calculating the ratio of the covered elements by the mapping rules to the total elements, which should be existing in order to get a meaningful stub. As a result we prove that we cover about 70 percent of the elements by the mapping rules while we show that the other 30 percent can't be extracted from the information available in the DFM.
Bei der Produktlinienentwicklung werden Software-Produktlinien(SPLs) meistens Featureorientiert strukturiert und organisiert. Um die gemeinsamen und variablen Merkmale der Produkte einer Produktlinie darzustellen, können Feature-Modelle verwendet werden. Ein Software-Werkzeug zum Erstellen und Editieren von Feature-Modellen ist FeatureIDE, welche die Zustände der Feature-Modelle als Dateien der Extensible Markup Language (XML) persistiert. Bei der Entwicklung von Software-Systemen existieren allerdings mehrere unterschiedliche Artefakte. Diese können sich Informationen mit den Feature-Modellen teilen. Um diese Artefakte und Modelle gemeinsam automatisch evolvieren zu können, werden Konsistenzerhaltungsansätze benötigt. Solche Ansätze sind jedoch nicht mit den persistierten XML-Dateien kompatibel.
In dieser Arbeit implementieren wir eine bidirektionale Modell-zu-Text-Transformation, welche die als XML-Dateien persistierten Zustände der FeatureIDE-Modelle in geeignete Modellrepräsentationen überführt, um daraus feingranulare Änderungssequenzen abzuleiten. Diese können zur deltabasierten Konsistenzerhaltung verwendet werden. Für die Modellrepräsentation verwenden wir ein bestehendes Metamodell für Variabilität. Zur Ableitung der Änderungssequenzen wird ein existierendes Konsistenzerhaltungsframework
eingesetzt. Wir validieren die Korrektheit der Transformation mithilfe von Round-Trip-Tests. Dabei zeigen wir, dass die in dieser Arbeit implementierte Transformation alle geteilten Informationen zwischen FeatureIDE und dem Variabilitäts-Metamodell korrekt transformiert. Zudem können mithilfe der in dieser Arbeit implementierten Transformation und mit dem verwendeten Konsistenzerhatlungsframework zu 94,44% korrekte feingranulare Änderungssequenzen aus den als XML-Datei persistierten Zuständen der FeatureIDE-Modelle abgeleitet werden. +
Konsistenzhaltung von Eingabemodellen für Architekturanalysen und statischen Quelltextanalysen für Sicherheit +
Architekturanalysen können in Architekturmodellen Sicherheitseigenschaften spezifizieren. Diese Spezifikationen können von statischen Sicherheitsanalysen anhand dem Quelltext überprüft werden. Dafür müssen sich diese Modelle alle auf demselben Stand befinden. Die manuelle Konsistenzhaltung der Modelle ist jedoch aufwändig.
Daher wird dieser Arbeit ein Konzept für eine automatische Konsistenzhaltung vier verschiedener Modelle umgesetzt, welche als Eingabemodelle für eine statische Sicherheitsanalyse dienen. Diese vier Modelle sind ein Architekturmodell, dessen Quelltext und jeweils dazu passende Annotationen für eine statische Sicherheitsanalyse. Es wird zunächst ein Konzept für die Konsistenzhaltung zwischen diesen vier Modelltypen entwickelt.
Für das entwickelte Konzept wurde anhand einer Fallstudie mit vier konkreten Metamodellen in dem Framework Vitruvius eine Konsistenzhaltung implementiert. Für diese wurde auf einer existierenden Konsistenzhaltung zwischen dem Quelltext und der Architekturmodellierung aufgebaut.
Diese Implementierung wurde anhand eines Testmodells evaluiert. Diese hat ergeben, dass es machbar ist, anhand des in dieser Arbeit vorgestellten Konzeptes eine Konsistenzhaltung für die Eingabemodelle zu implementieren. Jedoch ist die Implementierung der Regeln aufwändig bei komplexen Abbildungen zwischen den Elementen. +
Immer mehr Unternehmen stehen heutzutage vor dem Problem, dass eines oder mehrere ihrer Altsysteme auf einer monolithischen Softwarearchitektur basieren, die über Jahre hinweg immer mehr an Komplexität zugenommen hat. Die Weiterentwicklung eines solchen Altsystems ist aufwendig und dementsprechend mit hohen Kosten verbunden. Um diese Kosten längerfristig zu senken, können Architektur-Muster, wie die Microservices Architektur eingesetzt werden. Der Migrationsprozess von einer monolithischen Architektur, hin zu einer Microservices-Architektur, ein komplexer und fehleranfälliger Prozess.
Ziel dieser Masterthesis ist die Unterstützung eines solchen Migrationsprozess, indem ein Konzept für eine kontinuierliche Verfeinerung von automatisch extrahierten, architekturellen Performanz-Modellen entwickelt und in einem prototypischen Plug-in umgesetzt wird. Die Thesis beinhaltet ein Konzept zur Durchführung und Speicherung von manuellen Verfeinerungsschritten an extrahierten Performanz-Modellen. Außerdem ermöglicht die Thesis eine Zusammenführung von automatisch extrahierten Performanz-Modellen mit einem zu verfeinernden Performanz-Modell. Ein Ansatz zur Integration des erarbeiteten Konzepts in eine Continuous Integration Umgebung wird ebenfalls präsentiert. +
Konzept eines Dokumentationsassistenten zur Erzeugung strukturierter Anforderungen basierend auf Satzschablonen +
Um die Qualität und Glaubwürdigkeit eines Produktes zu erhalten, ist ein systematisches Anforderungsmanagement erforderlich, wobei die Merkmale eines Produkts durch Anforderungen beschrieben werden. Deswegen wurde im Rahmen dieser Arbeit ein Konzept für einen Dokumentationsassistenten entwickelt, mit dem Benutzer strukturierte Anforderungen basierend auf den Satzschablonen nach SOPHIST erstellen können. Dies beinhaltet einen linguistischen Aufbereitungsansatz, der semantische Rollen aus freiem Text extrahiert. Während des Dokumentationsprozesses wurden die semantischen Rollen benutzt, um die passendste Satzschablone zu identifizieren und diese als Hilfestellung dem Benutzer aufzuzeigen. Zudem wurde eine weitere Hilfestellung angeboten, nämlich die Autovervollständigung, die mithilfe von Markovketten das nächste Wort vorhersagen kann. Insgesamt wurden rund 500 Anforderungen aus verschiedenen Quellen herangezogen, um die Integrität des Konzepts zu bewerten. Die Klassifizierung der Texteingabe in eine Satzschablone erreicht ein F1-Maß von 0,559. Dabei wurde die Satzschablone für funktionale Anforderungen mit einem F1-Maß von 0,908 am besten identifiziert. Außerdem wurde der Zusammenhang zwischen den Hilfestellungen mithilfe eines Workshops bewertet. Hierbei konnte gezeigt werden, dass die Anwendung des vorliegenden Konzepts, die Vollständigkeit von Anforderungen verbessert und somit die Qualität der zu dokumentierenden Anforderungen steigert. +