1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
#include "Utility.h"
#include "binaryninjaapi.h"
#include "view/macho/machoview.h"
using namespace BinaryNinja;
BNSegmentFlag SegmentFlagsFromMachOProtections(int initProt, int maxProt)
{
uint32_t flags = 0;
if (initProt & MACHO_VM_PROT_READ)
flags |= SegmentReadable;
if (initProt & MACHO_VM_PROT_WRITE)
flags |= SegmentWritable;
if (initProt & MACHO_VM_PROT_EXECUTE)
flags |= SegmentExecutable;
if (((initProt & MACHO_VM_PROT_WRITE) == 0) && ((maxProt & MACHO_VM_PROT_WRITE) == 0))
flags |= SegmentDenyWrite;
if (((initProt & MACHO_VM_PROT_EXECUTE) == 0) && ((maxProt & MACHO_VM_PROT_EXECUTE) == 0))
flags |= SegmentDenyExecute;
return static_cast<BNSegmentFlag>(flags);
}
int64_t readSLEB128(const uint8_t*& current, const uint8_t* end)
{
uint8_t cur;
int64_t value = 0;
size_t shift = 0;
while (current != end)
{
cur = *current++;
value |= (cur & 0x7f) << shift;
shift += 7;
if ((cur & 0x80) == 0)
break;
}
value = (value << (64 - shift)) >> (64 - shift);
return value;
}
uint64_t readLEB128(const uint8_t*& current, const uint8_t* end)
{
if (current == nullptr)
return -1;
uint64_t result = 0;
int bit = 0;
do
{
if (current >= end)
return -1;
uint64_t slice = *current & 0x7f;
if (bit > 63)
return -1;
result |= (slice << bit);
bit += 7;
} while (*current++ & 0x80);
return result;
}
uint64_t readValidULEB128(const uint8_t*& current, const uint8_t* end)
{
uint64_t value = readLEB128(current, end);
if ((int64_t)value == -1)
throw ReadException();
return value;
}
void ApplySymbol(Ref<BinaryView> view, Ref<TypeLibrary> typeLib, Ref<Symbol> symbol, Ref<Type> type)
{
auto symbolAddress = symbol->GetAddress();
auto symbolName = symbol->GetFullName();
// Sometimes the symbol will be duplicated, so lets not do this work again.
if (view->GetSymbolByAddress(symbolAddress))
return;
// Define the symbol!
view->DefineAutoSymbol(symbol);
// Try and pull a type from a type library to apply at the symbol location.
// The type library type will take precedence over the passed in type.
Ref<Type> selectedType = type;
if (typeLib)
selectedType = view->ImportTypeLibraryObject(typeLib, {symbolName});
Ref<Function> func = nullptr;
if (symbol->GetType() == FunctionSymbol)
{
Ref<Platform> targetPlatform = view->GetDefaultPlatform();
// Make sure to check for already added function from the function table.
// Unless we have retrieved a type here we don't need to make a new function.
func = view->GetAnalysisFunction(targetPlatform, symbolAddress);
if (!func || selectedType != nullptr)
func = view->AddFunctionForAnalysis(targetPlatform, symbolAddress, false, selectedType);
// The above function might be overwritten so we also want to apply the type here.
if (func && selectedType != nullptr)
func->ApplyAutoDiscoveredType(selectedType);
}
else
{
// Other symbol types can just use this, they don't need to worry about linear sweep removing them.
view->DefineAutoSymbolAndVariableOrFunction(view->GetDefaultPlatform(), symbol, selectedType);
}
if (func)
{
// objective c type adjustment stuff.
if (symbolName == "_objc_msgSend")
{
func->SetHasVariableArguments(false);
}
else if (symbolName.find("_objc_retain_x") != std::string::npos
|| symbolName.find("_objc_release_x") != std::string::npos)
{
auto x = symbolName.rfind('x');
auto num = symbolName.substr(x + 1);
std::vector<FunctionParameter> callTypeParams;
auto cc = view->GetDefaultArchitecture()->GetCallingConventionByName("apple-arm64-objc-fast-arc-" + num);
if (auto idType = view->GetTypeByName({"id"}))
{
callTypeParams.emplace_back("obj", idType, true, Variable());
auto funcType = Type::FunctionType(idType, cc, callTypeParams);
func->SetUserType(funcType);
}
else
{
LogWarnF("Failed to find id type for {:#x}, objective-c processor not ran?", func->GetStart());
}
}
}
}
std::string BaseFileName(const std::string& path)
{
auto lastSlashPos = path.find_last_of("/\\");
if (lastSlashPos != std::string::npos)
return path.substr(lastSlashPos + 1);
return path;
}
bool IsSameFolderForFile(Ref<ProjectFile> a, Ref<ProjectFile> b)
{
if (!a && !b)
return true;
if (a && b)
return IsSameFolder(a->GetFolder(), b->GetFolder());
return false;
}
bool IsSameFolder(Ref<ProjectFolder> a, Ref<ProjectFolder> b)
{
if (!a && !b)
return true;
if (a && b)
return a->GetId() == b->GetId();
return false;
}
|
