758 research outputs found
Statistiline lÀhenemine mÀlulekete tuvastamiseks Java rakendustes
Kaasaegsed hallatud kĂ€itusaja keskkonnad (ingl. managed runtime environment) ja programmeerimiskeeled lihtsustavad rakenduste loomist ning haldamist. KĂ”ige levinumaks nĂ€iteks sÀÀrase keele ja keskkonna kohta on Java. Ăheks tĂ€htsaks hallatud kĂ€itusaja keskkonna ĂŒlesandeks on automaatne mĂ€luhaldus. Vaatamata sisseehitatud prĂŒgikoristajale, mĂ€lulekke probleem Javas on endiselt relevantne ning tĂ€hendab tarbetut mĂ€lu hoidmist. Probleem on eriti kriitiline rakendustes mis peaksid ööpĂ€evaringselt tĂ”rgeteta toimima, kuna mĂ€luleke on ĂŒks vĂ€heseid programmeerimisvigu mis vĂ”ib hĂ€vitada kogu Java rakenduse. Parimaks indikaatoriks otsustamaks kas objekt on kasutuses vĂ”i mitte on objekti viimane kasutusaeg. Selle meetrika pĂ”hiliseks puudujÀÀgiks on selle hind jĂ”udluse mĂ”ttes.
KĂ€esolev vĂ€itekiri uurib mĂ€lulekete problemaatikat Javas ning pakub vĂ€lja uudse mĂ€lulekkeid tuvastava ning diagnoosiva algoritmi. VĂ€itekirjas kirjeldatakse alternatiivset lĂ€henemisviisi objektide kasutuse hindamiseks. PĂ”hihĂŒpoteesiks on idee et lekkivaid objekte saab statistiliste meetoditega eristada mittelekkivatest kui vaadelda objektide populatsiooni eluiga erinevate gruppide lĂ”ikes. Pakutud lĂ€henemine on oluliselt odavama hinnaga jĂ”udluse mĂ”ttes, kuna objekti kohta on vaja salvestada infot ainult selle loomise hetkel. VĂ€itekirja uurimistöö tulemusi on rakendatud mĂ€lulekete tuvastamise tööriista Plumbr arendamisel, mida hetkel edukalt kasutatakse ka erinevates toodangkeskkondades.
PĂ€rast sissejuhatavaid peatĂŒkke, vĂ€itekirjas vaadeldakse siiani pakutud lahendusi ning on pakutud vĂ€lja ka nende meetodite klassifikatsioon. JĂ€rgnevalt on kirjeldatud statistiline baasmeetod mĂ€lulekete tuvastamiseks. Lisaks on analĂŒĂŒsitud ka kirjeldatud baasmeetodi puudujÀÀke. JĂ€rgnevalt on kirjeldatud kuidas said defineeritud lisamÔÔdikud mis aitasid masinĂ”ppe abil baasmeetodit tĂ€psemaks teha. Testandmeid masinĂ”ppe tarbeks on kogutud Plumbri abil pĂ€ris rakendustest ning toodangkeskkondadest. Lisaks, kirjeldatakse vĂ€itekirjas juhtumianalĂŒĂŒse ning vĂ”rdlust ĂŒhe olemasoleva mĂ€lulekete tuvastamise lahendusega.Modern managed runtime environments and programming languages greatly simplify creation and maintenance of applications. One of the best examples of such managed runtime environments and a language is the Java Virtual Machine and the Java programming language. Despite the built in garbage collector, the memory leak problem is still relevant in Java and means wasting memory by preventing unused objects from being removed. The problem of memory leaks is especially critical for applications, which are expected to work uninterrupted around the clock, as running out of memory is one of a few reasons which may cause the termination of the whole Java application. The best indicator of whether an object is used or not is the time of the last access. However, the main disadvantage of this metric is the incurred performance overhead.
Current thesis researches the memory leak problem and proposes a novel approach for memory leak detection and diagnosis. The thesis proposes an alternative approach for estimation of the 'unusedness' of objects. The main hypothesis is that leaked objects may be identified by applying statistical methods to analyze lifetimes of objects, by observing the ages of the population of objects grouped by their allocation points. Proposed solution is much more efficient performance-wise as for each object it is sufficient to record any information at the time of creation of the object. The research conducted for the thesis is utilized in a memory leak detection tool Plumbr.
After the introduction and overview of the state of the art, current thesis reviews existing solutions and proposes the classification for memory leak detection approaches. Next, the statistical approach for memory leak detection is described along with the description of the main metric used to distinguish leaking objects from non-leaking ones. Follows the analysis of this single metric. Based on this analysis additional metrics are designed and machine learning algorithms are applied on the statistical data acquired from real production environments from the Plumbr tool. Case studies of real applications and one previous solution for the memory leak detection are performed in order to evaluate performance overhead of the tool
Web Tracking: Mechanisms, Implications, and Defenses
This articles surveys the existing literature on the methods currently used
by web services to track the user online as well as their purposes,
implications, and possible user's defenses. A significant majority of reviewed
articles and web resources are from years 2012-2014. Privacy seems to be the
Achilles' heel of today's web. Web services make continuous efforts to obtain
as much information as they can about the things we search, the sites we visit,
the people with who we contact, and the products we buy. Tracking is usually
performed for commercial purposes. We present 5 main groups of methods used for
user tracking, which are based on sessions, client storage, client cache,
fingerprinting, or yet other approaches. A special focus is placed on
mechanisms that use web caches, operational caches, and fingerprinting, as they
are usually very rich in terms of using various creative methodologies. We also
show how the users can be identified on the web and associated with their real
names, e-mail addresses, phone numbers, or even street addresses. We show why
tracking is being used and its possible implications for the users (price
discrimination, assessing financial credibility, determining insurance
coverage, government surveillance, and identity theft). For each of the
tracking methods, we present possible defenses. Apart from describing the
methods and tools used for keeping the personal data away from being tracked,
we also present several tools that were used for research purposes - their main
goal is to discover how and by which entity the users are being tracked on
their desktop computers or smartphones, provide this information to the users,
and visualize it in an accessible and easy to follow way. Finally, we present
the currently proposed future approaches to track the user and show that they
can potentially pose significant threats to the users' privacy.Comment: 29 pages, 212 reference
Preventing Memory and Information LeakageIncinerator â Eliminating Stale References in Dynamic OSGi Applications
International audienceJava class loaders are commonly used in applicationservers to load, unload and update a set of classes as a unit.However, unloading or updating a class loader can introducestale references to the objects of the outdated class loader. Astale reference leads to a memory leak and, for an update,to an inconsistency between the outdated classes and theirreplacements. To detect and eliminate stale references, we proposeIncinerator, a Java virtual machine extension that introducesthe notion of an outdated class loader. Incinerator detects stalereferences and sets them to null during a garbage collection cycle.We evaluate Incinerator in the context of the OSGi frameworkand show that Incinerator correctly detects and eliminates stalereferences, including a bug in Knopflerfish. We also evaluatethe performance of Incinerator with the DaCapo benchmark onVMKit and show that Incinerator has an overhead of at most3.3%
Incinerator - Eliminating stale references in dynamic OSGi applications
International audienceJava class loaders are commonly used in application servers to load, unload and update a set of classes as a unit. However, unloading or updating a class loader can introduce stale references to the objects of the outdated class loader. A stale reference leads to a memory leak and, for an update, to an inconsistency between the outdated classes and their replacements. To detect and eliminate stale references, we propose Incinerator, a Java virtual machine extension that introduces the notion of an outdated class loader. Incinerator detects stale references and sets them to null during a garbage collection cycle. We evaluate Incinerator in the context of the OSGi framework and show that Incinerator correctly detects and eliminates stale references, including a bug in Knopflerfish. We also evaluate the performance of Incinerator with the DaCapo benchmark on VMKit and show that Incinerator has an overhead of at most 3.3
Information Flow Control with System Dependence Graphs - Improving Modularity, Scalability and Precision for Object Oriented Languages
Die vorliegende Arbeit befasst sich mit dem Gebiet der statischen Programmanalyse
â insbesondere betrachten wir Analysen, deren Ziel es ist,
bestimmte Sicherheitseigenschaften, wie etwa IntegritÀt und Vertraulichkeit,
fĂŒr Programme zu garantieren. HierfĂŒr verwenden wir sogenannte
AbhÀngigkeitsgraphen, welche das potentielle Verhalten des Programms
sowie den Informationsfluss zwischen einzelnen Programmpunkten
abbilden. Mit Hilfe dieser Technik können wir sicherstellen, dass z.B. ein
Programm keinerlei Information ĂŒber ein geheimes Passwort preisgibt.
Im Speziellen liegt der Fokus dieser Arbeit auf Techniken, die das
Erstellen des AbhÀngigkeitsgraphen verbessern, da dieser die Grundlage
fĂŒr viele weiterfĂŒhrende Sicherheitsanalysen bildet. Die vorgestellten
Algorithmen und Verbesserungen wurden in unser Analysetool Joana
integriert und als Open-Source öffentlich verfĂŒgbar gemacht. Zahlreiche
Kooperationen und Veröffentlichungen belegen, dass die Verbesserungen
an Joana auch in der Forschungspraxis relevant sind.
Diese Arbeit besteht im Wesentlichen aus drei Teilen. Teil 1 befasst sich
mit Verbesserungen bei der Berechnung des AbhÀngigkeitsgraphen, Teil 2
stellt einen neuen Ansatz zur Analyse von unvollstÀndigen Programmen
vor und Teil 3 zeigt aktuelle Verwendungsmöglichkeiten von Joana an
konkreten Beispielen.
Im ersten Teil gehen wir detailliert auf die Algorithmen zum Erstellen
eines AbhÀngigkeitsgraphen ein, dabei legen wir besonderes Augenmerk
auf die Probleme und Herausforderung bei der Analyse von Objektorientierten
Sprachen wie Java. So stellen wir z.B. eine Analyse vor,
die den durch Exceptions ausgelösten Kontrollfluss prÀzise behandeln
kann. HauptsÀchlich befassen wir uns mit der Modellierung von
Seiteneffekten, die bei der Kommunikation ĂŒber Methodengrenzen hinweg
entstehen können. Bei AbhÀngigkeitsgraphen werden Seiteneffekte, also
Speicherstellen, die von einer Methode gelesen oder verÀndert werden,
in Form von zusÀtzlichen Knoten dargestellt. Dabei zeigen wir, dass die
Art und Weise der Darstellung, das sogenannte Parametermodel, enormen
Einfluss sowohl auf die PrÀzision als auch auf die Laufzeit der gesamten
Analyse hat. Wir erklÀren die SchwÀchen des alten Parametermodels,
das auf ObjektbÀumen basiert, und prÀsentieren unsere Verbesserungen
in Form eines neuen Modells mit Objektgraphen. Durch das gezielte
Zusammenfassen von redundanten Informationen können wir die Anzahl
der berechneten Parameterknoten deutlich reduzieren und zudem
beschleunigen, ohne dabei die PrÀzision des resultierenden AbhÀngigkeitsgraphen
zu verschlechtern. Bereits bei kleineren Programmen im
Bereich von wenigen tausend Codezeilen erreichen wir eine im Schnitt
8-fach bessere Laufzeit â wĂ€hrend die PrĂ€zision des Ergebnisses in der
Regel verbessert wird. Bei gröĂeren Programmen ist der Unterschied
sogar noch deutlicher, was dazu fĂŒhrt, dass einige unserer TestfĂ€lle und
alle von uns getesteten Programme ab einer GröĂe von 20000 Codezeilen
nur noch mit Objektgraphen berechenbar sind. Dank dieser Verbesserungen
kann Joana mit erhöhter PrĂ€zision und bei wesentlich gröĂeren
Programmen eingesetzt werden.
Im zweiten Teil befassen wir uns mit dem Problem, dass bisherige,
auf AbhÀngigkeitsgraphen basierende Sicherheitsanalysen nur vollstÀndige
Programme analysieren konnten. So war es z.B. unmöglich,
Bibliothekscode ohne Kenntnis aller Verwendungsstellen zu betrachten
oder vorzuverarbeiten. Wir entdeckten bei der bestehenden Analyse
eine Monotonie-Eigenschaft, welche es uns erlaubt, Analyseergebnisse
von Programmteilen auf beliebige Verwendungsstellen zu ĂŒbertragen.
So lassen sich zum einen Programmteile vorverarbeiten und zum anderen
auch generelle Aussagen ĂŒber die Sicherheitseigenschaften von
Programmteilen treffen, ohne deren konkrete Verwendungsstellen zu
kennen. Wir definieren die Monotonie-Eigenschaft im Detail und skizzieren
einen Beweis fĂŒr deren Korrektheit. Darauf aufbauend entwickeln
wir eine Methode zur Vorverarbeitung von Programmteilen, die es uns
ermöglicht, modulare AbhÀngigkeitsgraphen zu erstellen. Diese Graphen
können zu einem spÀteren Zeitpunkt der jeweiligen Verwendungsstelle
angepasst werden. Da die prÀzise Erstellung eines modularen AbhÀngigkeitsgraphen
sehr aufwendig werden kann, entwickeln wir einen
Algorithmus basierend auf sogenannten Zugriffspfaden, der die Skalierbarkeit
verbessert. Zuletzt skizzieren wir einen Beweis, der zeigt, dass
dieser Algorithmus tatsÀchlich immer eine konservative Approximation
des modularen Graphen berechnet und deshalb die Ergebnisse darauf
aufbauender Sicherheitsanalysen weiterhin gĂŒltig sind.
Im dritten Teil prÀsentieren wir einige erfolgreiche Anwendungen
von Joana, die im Rahmen einer Kooperation mit Ralf KĂŒsters von der
UniversitÀt Trier entstanden sind. Hier erklÀren wir zum einen, wie
man unser Sicherheitswerkzeug Joana generell verwenden kann. Zum
anderen zeigen wir, wie in Kombination mit weiteren Werkzeugen und
Techniken kryptographische Sicherheit fĂŒr ein Programm garantiert
werden kann - eine Aufgabe, die bisher fĂŒr auf Informationsfluss basierende
Analysen nicht möglich war. In diesen Anwendungen wird
insbesondere deutlich, wie die im Rahmen dieser Arbeit vereinfachte
Bedienung die Verwendung von Joana erleichtert und unsere Verbesserungen
der PrÀzision des Ergebnisses die erfolgreiche Analyse erst
ermöglichen
- âŠ