Flexibele opake predicaten

Student:Sam De Creus
Richting:Master of Science in de industriële wetenschappen: informatica
Abstract:Het voorgaande werk met betrekking tot flexibele opake predikaten tracht de zwaktes van ob-fuscators die statische opake predikaten injecteren aan te pakken [5]. Als een aanvaller dezestatische predikaten gaat analyseren, zal snel opvallen dat de ingevoegde sprongen steeds in de-zelfde richting genomen worden. Een ander probleem is dat alle reeds bestaande obfuscatietoolsslechts een klein aantal opake predikaten kunnen gebruiken. Hierdoor kan patroonherkenninggebruikt worden om opake predikaten op te sporen en te verwijderen.De voorgestelde oplossing is een systeem waarbij de ontwikkelaar van een programma zelf op eenflexibele manier opake predikaten kan definiëren. Deze opake predikaten worden gebaseerd opeigenschappen van datastructuren die gebruikt worden in de te obfusceren programmacode. Deobfuscatiecode die geïnjecteerd wordt, zal dan instanties van de opgegeven datastructuren ma-nipuleren. Dit heeft tot gevolg dat de grens tussen de obfuscatiecode en de programmacode vooreen aanvaller moeilijker te bepalen valt. Dit heeft ook tot gevolg dat een aanvaller veranderingenzal zien in datastructuren in het geheugen wanneer de obfuscatiecode aangeroepen wordt. Eengroot voordeel is dat de obfuscatiecode niet hard gecodeerd wordt in de obfuscator, dit zorgtvoor grote flexibiliteit. Om de gebruiker van het systeem de mogelijkheid te geven informatiedoor te geven over de obfuscatiecode aan de obfuscator, werd een meta-API ontwikkeld. Opbasis van deze informatie weet de obfuscator op welke manier de datastructuur gemanipuleerdmoet worden om een opaak predikaat een bepaalde waarde te geven.Met deze masterproef trachten we de mogelijkheden van flexibele opake predikaten uit te brei-den en nog flexibeler te maken. Een eerste probleem die aangepakt zal worden is de flexibiliteitvan de meta-API. Dit is nodig zodat een gebruiker complexere opake predikaten kan definiëren,het wordt dan ook eenvoudiger een groter aantal opake predikaten te definiëren. Om de grenstussen obfuscatiecode en programmacode nog onduidelijker te maken, wordt er onderzocht ofbestaande programma-invarianten gebruikt kunnen worden om de datastructuren te manipu-leren. In het voorgaande werk werd er in het te beveiligen programma, per datastructuur ééninstantie gebruikt. Aangezien flexibele opake predikaten datastructuren manipuleren, kan hetvoorkomen dat sommige locaties in de programmacode niet geobfusceerd kunnen worden wegensafhankelijkheden met andere geïnjecteerde opake predikaten. Hierdoor wordt er gezocht naar eenmanier om meerdere instanties te gebruiken, zodat meer obfuscaties mogelijk zijn. Ten slottewordt er een manier gezocht om de performantieoverhead te beperken.
Abstract (Eng):Previous work involving flexible opaque predicates strives toovercome weaknesses of obfuscators that inject static opaquepredicates in programs. When an attacker analyses theseopaque predicates, he will notice that all injected jumps will betaken in the same direction. Another problem is that only a smallamount of opaque predicates is available for such obfuscators.Overuse of the same opaque predicates leads to easy detectionby means of pattern recognition.The authors of the previous work suggested a solution wherethe developer of a program can easily define flexible opaquepredicates based on data structures that are used in the protectedprogram. The obfuscation code that is injected into the programwill manipulate an instance of the given data structure in orderto blur the border between obfuscation code and the originalprogram code. A major advantage is that the obfuscation codedoes not have to be hard-coded into the program, this ensures ahigh order of flexibility. To give the user the possibility to giveinformation to the obfuscator about the predicates, a meta-APIwas developed. Based on this information given by the user, theobfuscator knows how the data structure has to be manipulatedin order to give a certain value to the predicate.The basic idea of this technique was to go over all basicblocks of a program and manipulate a data structure instanceon all incoming path of a basic block to give it certain proper-ties. The datastructure is manipulated by calling a set function,which has to be provided to the obfuscator, which is Diablo inthis case. Based on these properties the control-flow of theprogram would be split where one branch would go to the orig-inal next code, the other branch could be sent to any location inthe program as it would never be used. This split is based ona get function which returns a boolean value based on the stateof the given data structure instance. A technique borrowed andadapted from compiler design called liveness analysis was in-troduced to make sure that the data structure instance would notbe manipulated, so that the value of a previously set predicatewould not be made invalid. The goal of this masters thesis is to improve flexible opaquepredicates and to even extend their flexibility. A first point to betackled is to increase the flexibility of the previously mentionedmeta-API. This enables the user to define a larger set of predi-cates. Another goal is to further diminish the conceptual borderbetween obfuscation code and transformation code by using in-variants from the obfuscated program in the obfuscation code.We will make use of multiple instances of a given data structureto obfuscate the program, this will increase the amount of pos-sible obfuscation areas in the program. Finally we will try todecrease the performance overhead of the obfuscations by usingprofile information.