Segui questo link per vedere altri tipi di pubblicazioni sul tema: Decompiler.
Tesi sul tema "Decompiler"
Cita una fonte nei formati APA, MLA, Chicago, Harvard e in molti altri stili
Vedi i top-21 saggi (tesi di laurea o di dottorato) per l'attività di ricerca sul tema "Decompiler".
Accanto a ogni fonte nell'elenco di riferimenti c'è un pulsante "Aggiungi alla bibliografia". Premilo e genereremo automaticamente la citazione bibliografica dell'opera scelta nello stile citazionale di cui hai bisogno: APA, MLA, Harvard, Chicago, Vancouver ecc.
Puoi anche scaricare il testo completo della pubblicazione scientifica nel formato .pdf e leggere online l'abstract (il sommario) dell'opera se è presente nei metadati.
Vedi le tesi di molte aree scientifiche e compila una bibliografia corretta.
1
DAVIDSON, ANDREW JOSEPH. "SPADE: SEMANTICALLY PRESERVING ABSTRACT DECOMPILER EXPERIMENT". Thesis, The University of Arizona, 2008. http://hdl.handle.net/10150/190436.
Testo completo
2
Miecznikowski, Jerome. "New algorithms for a java decompiler and their implementation in Soot". Thesis, McGill University, 2003. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=79050.
Testo completoAbstract (sommario):
This thesis presents Dava, a Java bytecode to Java source code decompiler built on top of the Soot framework.The Java Virtual Machine Specification of valid bytecode is much less restrictive than the Java Language Specification of valid Java source programs. For example, bytecode has unstructured control flow, loose local typing, and few restrictions on method modifiers. By contrast, the Java language has highly structured control flow, strong local typing, and many restrictions on its method modifiers. The goal of this thesis was to build a tool that could correctly decompile the widest range of verifiable Java bytecode back into compilable Java source. This includes bytecode coming from other source languages, bytecode that has undergone certain types of obfuscation, and optimized bytecode. To accomplish this goal we created the Structure Encapsulation Tree data structure and a set of new decompiling algorithms.
The algorithms fall into three categories: regular control flow, exceptional control flow, and idioms.
3
Eriksson, David. "Designing an object-oriented decompiler : Decompilation support for Interactive Disassembler Pro". Thesis, Blekinge Tekniska Högskola, Institutionen för programvaruteknik och datavetenskap, 2002. http://urn.kb.se/resolve?urn=urn:nbn:se:bth-5604.
Testo completoAbstract (sommario):
Decompilation, or reverse compilation, takes a computer program and produces high-level code that works like the original source code. This makes it easier to understand a computer program when source code is not available. However, there are very few tools for decompilation available today. This report describes the design and implementation of Desquirr, a decompilation plug-in for Interactive Disassembler Pro. Desquirr has an object-oriented design and performs basic decompilation of programs running on Intel x86 processors. The low-level analysis uses knowledge about specialized compiler constructs, called idioms, to perform a more accurate decompilation. Desquirr implements data flow analysis, meaning the conversion from primitive machine code instructions into code in a high-level language. The major part of the data flow analysis is the Register Copy Propagation which builds high-level expressions from primitive instructions. Control flow analysis, meaning to restore high-level language constructs such as if/else and for loops, is not implemented. A high level representation of a piece of machine code contains the same information as an assembly language representation of the same machine code, but in a format that is easier to comprehend. Symbols such as ?*? and ?+? are used in high-level language expressions, compared to instructions such as ?mul? and ?add? in assembly language. Two small test cases which compares decompiled code with assembly language shows promising results in reducing the amount of information needed to comprehend a program.Dekompilering, eller omvänd kompilering, tar ett datorprogram och omvandlar det till högnivåspråk som fungerar som den ursprungliga källkoden. Detta gör det lättare att förstå ett datorprogram när källkod inte finns tillgänglig. Det finns väldigt få verktyg för dekompilering tillgängliga idag. Den här rapporten beskriver design och implementation av Desquirr, en dekomplator-plugin för Interactive Disassembler Pro. Desquirr har en objekt-orienterad design och utför grundläggande dekompilering av program som kör på Intel x86-processorer.
4
Žamberský, Zdeněk. "Zpětný překladač jazyka Java". Master's thesis, Vysoké učení technické v Brně. Fakulta strojního inženýrství, 2015. http://www.nusl.cz/ntk/nusl-232034.
Testo completoAbstract (sommario):
The goal was to create decompiler for Java programing language. Decompiler should reconstruct original Java source code from class files, representing its compiled form. First part of thesis focuses on Java langage, its compilation and structure of class file. Then Java Virtual Machine and its instruction set is discussed. After that thesis focuses on decompilation and algoritms designed and used for decompiler realization. Examples of decompiled code are presented.
5
Kollár, Jaroslav. "Optimalizace LLVM IR pro účely zpětného překladu". Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2015. http://www.nusl.cz/ntk/nusl-264955.
Testo completoAbstract (sommario):
This master's thesis describes the design and implementation of optimizations in the middle-end part of a retargetable decompiler developed by AVG Technologies. The purpose of these optimizations is to improve readability of the produced source code and improve existing optimizations in the back-end part. In the introduction, basic information about reverse engineering and decompilation is provided. Then, a description of state of the retargetable decompiler before this work is given. After that, the main part of this work is presented, which describes the design and implementation of the proposed optimizations. Then, the techniques that were used for testing are described. This description is followed by a summary of the achieved results. The present work is concluded by a discussion of possible future development.
6
Macko, Lukáš. "Dekódování binárního kódu do vyšší formy reprezentace". Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2015. http://www.nusl.cz/ntk/nusl-264983.
Testo completoAbstract (sommario):
The thesis deals with reverse techniques in software engineering. It presents practical application of software reverse engineering, used tools and approaches. The topic of instruction decoding is discussed in detail. Two basic methods are presented-linear sweep and recursive descent. Their strengths and weaknesses are highlighted. Subsequently a decompiler developed by AVG Technologies is introduced. The decompiler is retargetable. This feature allows to decompile applications of multiple platforms into various target languages. The aim of the thesis is to design and implement algorithm for decoding binary files into high-level representation. The designed algorithm is based on modified recursive descent algorithm, which uses control flow information. In order to achieve more accurate decoding results, symbol table records and other additional information are used. The proposed algorithm was implemented for the AVG Technologies retargetable decompiler. The tests showed that the implemented algorithm improved the function detection in decoded programs. Furthermore, the implemented solution allows to decode files that could not be analysed using the previous version of the decompiler.
7
kalle, Sushma. "Semantic-aware Stealthy Control Logic Infection Attack". ScholarWorks@UNO, 2018. https://scholarworks.uno.edu/td/2512.
Testo completoAbstract (sommario):
In this thesis work we present CLIK, a new, automated, remote attack on the control logic of a programmable logic controller (PLC) in industrial control systems. The CLIK attack modifies the control logic running in a remote target PLC automatically to disrupt a physical process. We implement the CLIK attack on a real PLC. The attack is initiated by subverting the security measures that protect the control logic in a PLC. We found a critical (zero-day) vulnerability, which allows the attacker to overwrite password hash in the PLC during the authentication process. Next, CLIK retrieves and decompiles the original logic and injects a malicious logic into it and then, transfers the infected logic back to the PLC. To hide the infection, we propose a virtual PLC that engages the software the virtual PLC intercepts the request and then, responds with the original (uninfected) control logic to the software.
8
Matula, Peter. "Rekonstrukce datových typů při zpětném překladu kódu". Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2013. http://www.nusl.cz/ntk/nusl-236191.
Testo completoAbstract (sommario):
This document describes methods for a reconstruction of data types in the decompilation problem. It defines the concept of reverse engineering and introduces decompiler developed by the Lissom project. It presents existing methods of reconstruction of the simple and complex data types, and explains in detail approaches based on data-flow analysis and analysis of the memory operation offsets. The core of this thesis is the design of a new technique of reconstructing simple and complex data types, suitable for deployment in a retargetable decompiler environment of the Lissom project. Basic principles of the new technique, its implementation and related changes in decompiler and intermediate language are described. The solution is tested and the conclusion discusses the achievements, shortcomings and direction of the further work.
9
Ilsoo, Jeon. "LLVM-IR based Decompilation". Wright State University / OhioLINK, 2019. http://rave.ohiolink.edu/etdc/view?acc_num=wright1559500021466716.
Testo completo
10
Křoustek, Jakub. "Analýza a převod kódů do vyššího programovacího jazyka". Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2009. http://www.nusl.cz/ntk/nusl-236651.
Testo completoAbstract (sommario):
This paper describes methods and procedures used for code analysis and transformation. It contains basic information of a science discipline called reverse engineering and its use in information technologies. The primary objective is a construction of a generic reverse compiler or decompiler, i.e. tool that can recompile from binary form (optionally from symbolic machine code) to a high level language. This operation is highly dependent on the concrete instruction set and processor architecture. This problem is solved with description of semantic of each instruction by a special language designed for this use. The output is the high level language code and is functionally equivalent to the input. The program is therefore able to work with each instruction set and code written by it can be transformed into the chosen high level language. This proposal is implemented in practice as a part of project Lissom. Generic decompiler is completely new idea. The thesis contains entirely new techniques from theory of compilers and optimizations made by the author.
11
Naeem, Nomair A. "Programmer-friendly decompiled Java". Thesis, McGill University, 2006. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=101644.
Testo completoAbstract (sommario):
Java decompilers convert Java class files to Java source. Common Java decompilers are javac-specific decompilers since they target bytecode produced from a particular javac compiler. We present work carried out on Dava, a tool-independent decompiler that decompiles bytecode produced from any compiler. A known deficiency of tool-independent decompilers is the generation of complicated decompiled Java source which does not resemble the original source as closely as output produced by javac-specific decompilers. This thesis tackles this short-coming, for Dava, by introducing a new back-end consisting of simplifying transformations.The work presented can be broken into three major categories: transformations using tree traversals and pattern matching to simplify the control flow, the creation of a flow analysis framework for an Abstract Syntax Tree (AST) representation of Java source code and the implementation of flow analyses with their use in complicated transformations.
The pattern matching transformations rewrite the ASTs to semantically-equivalent ASTs that correspond to code that is easier for programmers to understand. The targeted Java constructs include If and If-Else aggregation, for-loop creation and the removal of abrupt control flow. Pattern matching using tree traversals has its limitations. Thus, we introduce a new structure-based data flow analysis framework that can be used to gather information required by more complex transformations. Popular compiler analyses e.g., reaching definitions, constant propagation etc. were implemented using the framework. Information from these analyses is then leveraged to perform more advanced AST transformations.
We performed experiments comparing different decompiler outputs for different sources of bytecode. The results from these experiments indicate that the new Dava back-end considerably improves code comprehensibility and readability.
12
Eklind, Robin. "Compositional Decompilation using LLVM IR". Thesis, Uppsala universitet, Institutionen för informationsteknologi, 2015. http://urn.kb.se/resolve?urn=urn:nbn:se:uu:diva-279307.
Testo completoAbstract (sommario):
Decompilation or reverse compilation is the process of translating low-level machine-readable code into high-level human-readable code. The problem is non-trivial due to the amount of information lost during compilation, but it can be divided into several smaller problems which may be solved independently. This report explores the feasibility of composing a decompilation pipeline from independent components, and the potential of exposing those components to the end-user. The components of the decompilation pipeline are conceptually grouped into three modules. Firstly, the front-end translates a source language (e.g. x86 assembly) into LLVM IR; a platform-independent low-level intermediate representation. Secondly, the middle-end structures the LLVM IR by identifying high-level control flow primitives (e.g. pre-test loops, 2-way conditionals). Lastly, the back-end translates the structured LLVM IR into a high-level target programming language (e.g. Go). The control flow analysis stage of the middle-end uses subgraph isomorphism search algorithms to locate control flow primitives in CFGs, both of which are described using Graphviz DOT files. The decompilation pipeline has been proven capable of recovering nested pre-test and post-test loops (e.g. while, do-while), and 1-way and 2-way conditionals (e.g. if, if-else) from LLVM IR. Furthermore, the data-driven design of the control flow analysis stage facilitates extensions to identify new control flow primitives. There is huge potential for future development. The Go output could be made more idiomatic by extending the post-processing stage, using components such as Grind by Russ Cox which moves variable declarations closer to their usage. The language-agnostic aspects of the design will be validated by implementing components in other languages; e.g. data flow analysis in Haskell. Additional back-ends (e.g. Python output) will be implemented to verify that the general decompilation tasks (e.g. control flow analysis, data flow analysis) are handled by the middle-end.BSc dissertation written during an ERASMUS exchange from Uppsala University to the University of Portsmouth.
13
Končický, Jaromír. "Využití dynamické analýzy kódu při zpětném překladu". Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2014. http://www.nusl.cz/ntk/nusl-236118.
Testo completoAbstract (sommario):
As a part of the Lissom project, a retargetable decompiler is being developed. Its main purpose is to decompile programs for a particular microprocessor architecture into a high-level programming language. In present, methods of dynamic code analysis are not used during decompilation. However, we can significantly improve the decompilation results by using these methods. Design of dynamic-analysis methods is the main task of this thesis. In this thesis, reverse engineering and Lissom decompiler are described. Furthermore, general dynamic analysis methods, such as instrumentation and emulation, are described. The information we can obtain by using dynamic analysis and its usage during decompilation is proposed.
14
Kábele, Břetislav. "Metody detekce funkcí při zpětném překladu kódu". Master's thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2012. http://www.nusl.cz/ntk/nusl-236601.
Testo completoAbstract (sommario):
This work describes methods of functions detection in decompilation. It contains basic information about reverse engineering and its applications in computer science and beyond. Decompiler developed by research group Lissom at FIT VUT Brno is introduced. The main objective is to elucidate several methods of functions detection, discuss their advantages and disadvantages, and identify the problems of functions detection. After detecting the start, end and body of function, it is needed to find the parameters and return values. There are some algorithms presented in this area. The output of this thesis is design and implementation of architecture independent function detection and parameter detection.
15
Křoustek, Jakub. "Rekonfigurovatelná analýza strojového kódu". Doctoral thesis, Vysoké učení technické v Brně. Fakulta informačních technologií, 2015. http://www.nusl.cz/ntk/nusl-261276.
Testo completoAbstract (sommario):
Analýza softwaru je metodologie, jejímž účelem je analyzovat chování daného programu. Jednotlivé metody této analýzy je možné využít i v dalších oborech, jako je zpětné inženýrství, migrace kódu apod. V této práci se zaměříme na analýzu strojového kódu, na zjištění nedostatků existujících metod a na návrh metod nových, které umožní rychlou a přesnou rekonfigurovatelnou analýzu kódu (tj. budou nezávislé na konkrétní cílové platformě). Zkoumány budou dva typy analýz - dynamická (tj. analýza za běhu aplikace) a statická (tj. analýza aplikace bez jejího spuštění). Přínos této práce v rámci dynamické analýzy je realizován jako rekonfigurovatelný ladicí nástroj a dále jako dva typy tzv. rekonfigurovatelného translátovaného simulátoru. Přínos v rámci statické analýzy spočívá v navržení a implementování rekonfigurovatelného zpětného překladače, který slouží pro transformaci strojového kódu zpět do vysokoúrovňové reprezentace. Všechny tyto nástroje jsou založeny na nových metodách navržených autorem této práce. Na základě experimentálních výsledků a ohlasů od uživatelů je možné usuzovat, že tyto nástroje jsou plně srovnatelné s existujícími (komerčními) nástroji a nezřídka dosahují i lepších výsledků.
16
Hsieh, Wei-Yu, e 謝韋佑. "Android’s Dex Decompiler: Type Inference Part". Thesis, 2011. http://ndltd.ncl.edu.tw/handle/61637654605397700984.
Testo completoAbstract (sommario):
碩士國立臺灣大學
資訊工程學研究所
99
Currently, Android applications are mainly written in Java language. After using javac to compile these Java source files into Java class files, we use Android dx compiler to convert these Java class files to dex files furthermore. Dex file is a kind of register-based instruction set and optimized for mobile devices. At present, the binary transformations for dex are not rich, but the binary transformation for Java are developed for many years. Therefore, our main target is joining dex file to Java binary transformations. Dx compiler would not write local variable type information into dex file in codegen step. If we want to join dex file to Java binary transformation family, the main problem is that we need to infer the local variable type. Furthermore, Android system takes a lazy attitude about type. It causes type inference in dex more difficult. In this thesis, we provide and implement a type inferencer which can read dex file, transform it to the intermediate representation, and infer the local variable type. We also successfully decompile program from dex file format to the java file format by our experimentation.
17
Wang, Chin-Chih, e 王勁智. "Android’s Dex Decompiler : Control Structure Part". Thesis, 2011. http://ndltd.ncl.edu.tw/handle/59675108660166331292.
Testo completoAbstract (sommario):
碩士國立臺灣大學
資訊工程學研究所
99
Because Android is more and more popular, users will have different optimization request about Android applications in the near future. They also have to transform the file into different format, such as transforming Android dex file to Java source file. However, the resources of binary transformations and optimization frameworks for Java source and Java class file are much more fruitful than those for Android dex file. In this thesis, we want to create a binary transformation path from Android dex file to Java source and Java class file. Our goal is to develop a Dex-to-Java decompiler. This thesis will focus on control structure creation. We adopt the goto-elimination algorithm of a Class-to-Java decompiler. And then, according to Android dex property, we modify the algorithm in order to remove goto instructions and construct corresponding control structures. Finally, we can write down the Java source file according to these control structures.
18
Ching-Chung, Hsi, e 徐慶鐘. "Design and Implementation of a Decompiler". Thesis, 1994. http://ndltd.ncl.edu.tw/handle/64185303402082949154.
Testo completoAbstract (sommario):
碩士淡江大學
資訊管理研究所
82
Decompilation, the reverse process of compiling, is the process to translate automatically a low-level program into an equivalent high-level program. The technique can translating unstructed programs into structured programs. It is also helpful in software quality evaluation and in anti-imitation. In this thesis, we precisely define the "flow graph" -- the data structure representing the flow of control , and the syntax diagram -- the data structure representing the program syntax. The complex process of decompilation is analyzed and outlined into four translation phases. A program in machine language is translated firstly through "input translation" into a flow graph. And it is gradually translated through "control-flow translation" and "data-flow translation" into a syntax diagram. At last, it is translated through "output translation" into a high-level program. We invoke the technique of natural loops in compiler theory to identify all the loops in a flow graph. Furthermore, we present a refinement in the treatment of common headers. The algorithm of control-flow translation is presented, and all the primary translating subroutines are precisely discussed. A prototype of a decompiler based on the above scheme has been implemented in C language. Due to the complexity of the project, the phase of data-flow translation is temporarily eliminated as a future work. After testing , it is proved that our system is execllent in both functionality and efficency.
19
Hu, Chih-Ching, e 胡志慶. "Design and Implementation of a Java Decompiler". Thesis, 2005. http://ndltd.ncl.edu.tw/handle/32462783469749202463.
Testo completoAbstract (sommario):
碩士淡江大學
資訊管理學系碩士班
93
The decompilation is transforming a low-level language into an equivalent high-level language. This research aims to extracts the control-flow from decompiling the specific Java class file, and then identifies its loops and the selection structure. Finally, we use the instruction reorganization technology to archive the high-level structured program. This thesis plans a framework of decompilation and divides the entire transformation procedure to five steps: (1) translates into the Class Structure from a Java class file via “input translation", (2) translates into the Java Assembly(JASM) instruction via "disassembly", (3) transforms the flow graph which is composed by the Java Assembly(JASM) instruction by processing through "flow graph construction", (4) translates into a low-level syntax diagram via "control-flow translation", and (5) translates through "instruction reorganization" into a high-level syntax diagram and then outputs the high-level structured program.
20
Chang, Kai-Fu, e 張凱富. "Possible Improvements In Java Decompiler Through Redesigning". Thesis, 2017. http://ndltd.ncl.edu.tw/handle/287c9j.
Testo completoAbstract (sommario):
碩士國立臺灣大學
資訊工程學研究所
105
The ultimate goal of our research is to manage to decompile .class files into Java source code files. However, the current state-of-the-art decompilation technology cannot fully accomplish this goal for several reasons. At the time of publication of this article, most of the current available decompilers either produced exceptions during decompilation or failed to decompile Jave bytecodes to logically equivalent Java source code. The others just resulted in dumping assembly-like code to terminate decompilation. Hence, in order to reach the ultimate goal, we conducted the reverse-engineering on the ”Procyon” decompilation frameworks which we considered the best decompilation tool by far. In our research, we have analyzed the designs of Procyon frameworks by identifying the underlying design patterns, reconstructed the requirements by the designs, and finally proposed our redesign as the results of our research that we think is an improvement. Our redesign mainly improves time efficiency and reduces memory footprints. In the future, we will implement our design to complete Procyon frameworks and hope that we will fix most existing bugs to achieve a breakthrough of successfully building a decompiler that delivers.
21
Mráček, Jakub. "Dekompilátor pro Objective-C". Master's thesis, 2016. http://www.nusl.cz/ntk/nusl-352766.
Testo completoAbstract (sommario):
Objective-C is a popular programming language primarily used on the OS X and iOS platforms. We present a practical approach to decompilation of programs written in Objective-C and compiled for the x86 and AArch64 architectures using LLVM. Based on already-known generic reverse engineering techniques and compiler theory, this thesis analyzes new challenges and opportunities that occur in Objective-C binaries. We then offer solutions and algorithms that allow a decompiler to better recognize the high-level structures commonly used in Objective-C source codes. The thesis introduces an implementation of a new decompiler called "Cricket", an interactive GUI application for OS X, which uses the described algorithms and pattern matching methods to reconstruct source code in Objective-C. The decompiler tries to maximize readability of the output and allows user interaction to further modify the generated source code. The implemented software is then evaluated on a popular open-source framework and the results are compared to a competing product. Powered by TCPDF (www.tcpdf.org)