OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "courgette/program_detector.h" | 5 #include "courgette/program_detector.h" |
6 | 6 |
7 #include <utility> | |
8 | |
9 #include "courgette/assembly_program.h" | |
10 #include "courgette/disassembler.h" | 7 #include "courgette/disassembler.h" |
11 #include "courgette/disassembler_elf_32_arm.h" | 8 #include "courgette/disassembler_elf_32_arm.h" |
12 #include "courgette/disassembler_elf_32_x86.h" | 9 #include "courgette/disassembler_elf_32_x86.h" |
13 #include "courgette/disassembler_win32_x64.h" | 10 #include "courgette/disassembler_win32_x64.h" |
14 #include "courgette/disassembler_win32_x86.h" | 11 #include "courgette/disassembler_win32_x86.h" |
15 | 12 |
16 namespace courgette { | 13 namespace courgette { |
17 | 14 |
18 namespace { | |
19 | |
20 // Returns a new instance of Disassembler subclass if binary data given in | |
21 // |buffer| and |length| matches a known binary format, otherwise null. | |
22 std::unique_ptr<Disassembler> DetectDisassembler(const uint8_t* buffer, | 15 std::unique_ptr<Disassembler> DetectDisassembler(const uint8_t* buffer, |
23 size_t length) { | 16 size_t length) { |
24 std::unique_ptr<Disassembler> disassembler; | 17 std::unique_ptr<Disassembler> disassembler; |
25 | 18 |
26 if (DisassemblerWin32X86::QuickDetect(buffer, length)) { | 19 if (DisassemblerWin32X86::QuickDetect(buffer, length)) { |
27 disassembler.reset(new DisassemblerWin32X86(buffer, length)); | 20 disassembler.reset(new DisassemblerWin32X86(buffer, length)); |
28 if (disassembler->ParseHeader()) | 21 if (disassembler->ParseHeader()) |
29 return disassembler; | 22 return disassembler; |
30 } | 23 } |
31 if (DisassemblerWin32X64::QuickDetect(buffer, length)) { | 24 if (DisassemblerWin32X64::QuickDetect(buffer, length)) { |
32 disassembler.reset(new DisassemblerWin32X64(buffer, length)); | 25 disassembler.reset(new DisassemblerWin32X64(buffer, length)); |
33 if (disassembler->ParseHeader()) | 26 if (disassembler->ParseHeader()) |
34 return disassembler; | 27 return disassembler; |
35 } | 28 } |
36 if (DisassemblerElf32X86::QuickDetect(buffer, length)) { | 29 if (DisassemblerElf32X86::QuickDetect(buffer, length)) { |
37 disassembler.reset(new DisassemblerElf32X86(buffer, length)); | 30 disassembler.reset(new DisassemblerElf32X86(buffer, length)); |
38 if (disassembler->ParseHeader()) | 31 if (disassembler->ParseHeader()) |
39 return disassembler; | 32 return disassembler; |
40 } | 33 } |
41 if (DisassemblerElf32ARM::QuickDetect(buffer, length)) { | 34 if (DisassemblerElf32ARM::QuickDetect(buffer, length)) { |
42 disassembler.reset(new DisassemblerElf32ARM(buffer, length)); | 35 disassembler.reset(new DisassemblerElf32ARM(buffer, length)); |
43 if (disassembler->ParseHeader()) | 36 if (disassembler->ParseHeader()) |
44 return disassembler; | 37 return disassembler; |
45 } | 38 } |
46 return nullptr; | 39 return nullptr; |
47 } | 40 } |
48 | 41 |
49 Status ParseDetectedExecutableInternal( | |
50 const uint8_t* buffer, | |
51 size_t length, | |
52 bool annotate_labels, | |
53 std::unique_ptr<AssemblyProgram>* output) { | |
54 output->reset(); | |
55 | |
56 std::unique_ptr<Disassembler> disassembler( | |
57 DetectDisassembler(buffer, length)); | |
58 if (!disassembler) | |
59 return C_INPUT_NOT_RECOGNIZED; | |
60 | |
61 std::unique_ptr<AssemblyProgram> program = | |
62 disassembler->Disassemble(annotate_labels); | |
63 if (!program.get()) | |
64 return C_DISASSEMBLY_FAILED; | |
65 | |
66 *output = std::move(program); | |
67 return C_OK; | |
68 } | |
69 | |
70 } // namespace | |
71 | |
72 Status DetectExecutableType(const uint8_t* buffer, | 42 Status DetectExecutableType(const uint8_t* buffer, |
73 size_t length, | 43 size_t length, |
74 ExecutableType* type, | 44 ExecutableType* type, |
75 size_t* detected_length) { | 45 size_t* detected_length) { |
76 std::unique_ptr<Disassembler> disassembler( | 46 std::unique_ptr<Disassembler> disassembler( |
77 DetectDisassembler(buffer, length)); | 47 DetectDisassembler(buffer, length)); |
78 | 48 |
79 if (!disassembler) { // We failed to detect anything. | 49 if (!disassembler) { // We failed to detect anything. |
80 *type = EXE_UNKNOWN; | 50 *type = EXE_UNKNOWN; |
81 *detected_length = 0; | 51 *detected_length = 0; |
82 return C_INPUT_NOT_RECOGNIZED; | 52 return C_INPUT_NOT_RECOGNIZED; |
83 } | 53 } |
84 | 54 |
85 *type = disassembler->kind(); | 55 *type = disassembler->kind(); |
86 *detected_length = disassembler->length(); | 56 *detected_length = disassembler->length(); |
87 return C_OK; | 57 return C_OK; |
88 } | 58 } |
89 | 59 |
90 Status ParseDetectedExecutable(const uint8_t* buffer, | |
91 size_t length, | |
92 std::unique_ptr<AssemblyProgram>* output) { | |
93 return ParseDetectedExecutableInternal(buffer, length, false, output); | |
94 } | |
95 | |
96 Status ParseDetectedExecutableWithAnnotation( | |
97 const uint8_t* buffer, | |
98 size_t length, | |
99 std::unique_ptr<AssemblyProgram>* output) { | |
100 return ParseDetectedExecutableInternal(buffer, length, true, output); | |
101 } | |
102 | |
103 } // namespace courgette | 60 } // namespace courgette |
OLD | NEW |