dyld-851.27.tar.gz
[apple/dyld.git] / dyld3 / MachOAnalyzer.h
1 /*
2 * Copyright (c) 2017 Apple Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. Please obtain a copy of the License at
10 * http://www.opensource.apple.com/apsl/ and read it before using this
11 * file.
12 *
13 * The Original Code and all software distributed under the License are
14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
18 * Please see the License for the specific language governing rights and
19 * limitations under the License.
20 *
21 * @APPLE_LICENSE_HEADER_END@
22 */
23
24 #ifndef MachOAnalyzer_h
25 #define MachOAnalyzer_h
26
27
28 #include "MachOLoaded.h"
29 #include "Array.h"
30 #include "ClosureFileSystem.h"
31
32
33 namespace dyld3 {
34
35 // Extra functionality on loaded mach-o files only used during closure building
36 struct VIS_HIDDEN MachOAnalyzer : public MachOLoaded
37 {
38 // protected members of subclass promoted to public here
39 using MachOLoaded::SegmentInfo;
40 using MachOLoaded::SectionInfo;
41 using MachOLoaded::forEachSegment;
42 using MachOLoaded::forEachSection;
43 using MachOLoaded::forEachDependentDylib;
44 using MachOLoaded::getDylibInstallName;
45 using MachOLoaded::FoundSymbol;
46 using MachOLoaded::findExportedSymbol;
47 using MachOLoaded::forEachGlobalSymbol;
48 using MachOLoaded::forEachLocalSymbol;
49 using MachOFile::canBePlacedInDyldCache;
50 using MachOFile::forEachLoadCommand;
51 using MachOFile::removeLoadCommand;
52
53 enum class Rebase {
54 unknown,
55 pointer32,
56 pointer64,
57 textPCrel32,
58 textAbsolute32,
59 };
60
61 static bool loadFromBuffer(Diagnostics& diag, const closure::FileSystem& fileSystem,
62 const char* path, const GradedArchs& archs, Platform platform,
63 closure::LoadedFileInfo& info);
64 static closure::LoadedFileInfo load(Diagnostics& diag, const closure::FileSystem& fileSystem,
65 const char* logicalPath, const GradedArchs& archs, Platform platform, char realerPath[MAXPATHLEN]);
66 static const MachOAnalyzer* validMainExecutable(Diagnostics& diag, const mach_header* mh, const char* path, uint64_t sliceLength,
67 const GradedArchs& archs, Platform platform);
68
69 typedef void (^ExportsCallback)(const char* symbolName, uint64_t imageOffset, uint64_t flags,
70 uint64_t other, const char* importName, bool& stop);
71 bool validMachOForArchAndPlatform(Diagnostics& diag, size_t mappedSize, const char* path, const GradedArchs& archs, Platform platform, bool isOSBinary) const;
72
73 // Caches data useful for converting from raw data to VM addresses
74 struct VMAddrConverter {
75 uint64_t preferredLoadAddress = 0;
76 intptr_t slide = 0;
77 uint16_t chainedPointerFormat = 0;
78 bool contentRebased = false;
79 #if !(BUILDING_LIBDYLD || BUILDING_DYLD)
80 enum class SharedCacheFormat : uint8_t {
81 none = 0,
82 v2_x86_64_tbi = 1,
83 v3 = 2
84 };
85 SharedCacheFormat sharedCacheChainedPointerFormat = SharedCacheFormat::none;
86 #endif
87
88 uint64_t convertToVMAddr(uint64_t v) const;
89 };
90
91 VMAddrConverter makeVMAddrConverter(bool contentRebased) const;
92
93 uint64_t mappedSize() const;
94 bool hasObjC() const;
95 bool hasPlusLoadMethod(Diagnostics& diag) const;
96 bool usesObjCGarbageCollection() const;
97 bool isSwiftLibrary() const;
98 uint64_t preferredLoadAddress() const;
99 void forEachRPath(void (^callback)(const char* rPath, bool& stop)) const;
100 bool hasProgramVars(Diagnostics& diag, uint32_t& progVarsOffset) const;
101 void forEachCDHash(void (^handler)(const uint8_t cdHash[20])) const;
102 bool hasCodeSignature(uint32_t& fileOffset, uint32_t& size) const;
103 bool usesLibraryValidation() const;
104 bool isRestricted() const;
105 bool getEntry(uint64_t& offset, bool& usesCRT) const;
106 bool isSlideable() const;
107 bool hasInitializer(Diagnostics& diag, const VMAddrConverter& vmAddrConverter, const void* dyldCache=nullptr) const;
108 void forEachInitializerPointerSection(Diagnostics& diag, void (^callback)(uint32_t sectionOffset, uint32_t sectionSize, const uint8_t* content, bool& stop)) const;
109 void forEachInitializer(Diagnostics& diag, const VMAddrConverter& vmAddrConverter, void (^callback)(uint32_t offset), const void* dyldCache=nullptr) const;
110 bool hasTerminators(Diagnostics& diag, const VMAddrConverter& vmAddrConverter) const;
111 void forEachTerminator(Diagnostics& diag, const VMAddrConverter& vmAddrConverter, void (^callback)(uint32_t offset)) const;
112 void forEachDOFSection(Diagnostics& diag, void (^callback)(uint32_t offset)) const;
113 uint32_t segmentCount() const;
114 void forEachExportedSymbol(Diagnostics& diag, ExportsCallback callback) const;
115 void forEachWeakDef(Diagnostics& diag, void (^callback)(bool strongDef, uint32_t dataSegIndex, uint64_t dataSegOffset,
116 uint64_t addend, const char* symbolName, bool& stop)) const;
117 void forEachIndirectPointer(Diagnostics& diag, void (^handler)(uint64_t pointerAddress, bool bind, int bindLibOrdinal,
118 const char* bindSymbolName, bool bindWeakImport, bool bindLazy, bool selfModifyingStub, bool& stop)) const;
119 void forEachInterposingSection(Diagnostics& diag, void (^handler)(uint64_t vmOffset, uint64_t vmSize, bool& stop)) const;
120 const void* content(uint64_t vmOffset);
121 void forEachLocalReloc(void (^handler)(uint64_t runtimeOffset, bool& stop)) const;
122 void forEachExternalReloc(void (^handler)(uint64_t runtimeOffset, int libOrdinal, const char* symbolName, bool& stop)) const;
123
124 const void* getRebaseOpcodes(uint32_t& size) const;
125 const void* getBindOpcodes(uint32_t& size) const;
126 const void* getLazyBindOpcodes(uint32_t& size) const;
127 const void* getSplitSeg(uint32_t& size) const;
128 bool hasSplitSeg() const;
129 bool isSplitSegV1() const;
130 bool isSplitSegV2() const;
131 uint64_t segAndOffsetToRuntimeOffset(uint8_t segIndex, uint64_t segOffset) const;
132 bool hasLazyPointers(uint32_t& runtimeOffset, uint32_t& size) const;
133 void forEachRebase(Diagnostics& diag, bool ignoreLazyPointer, void (^callback)(uint64_t runtimeOffset, bool& stop)) const;
134 void forEachRebase(Diagnostics& diag, void (^callback)(uint64_t runtimeOffset, bool isLazyPointerRebase, bool& stop)) const;
135 void forEachTextRebase(Diagnostics& diag, void (^callback)(uint64_t runtimeOffset, bool& stop)) const;
136 void forEachBind(Diagnostics& diag, void (^callback)(uint64_t runtimeOffset, int libOrdinal, const char* symbolName,
137 bool weakImport, bool lazyBind, uint64_t addend, bool& stop),
138 void (^strongHandler)(const char* symbolName)) const;
139 void forEachBind(Diagnostics& diag, void (^callback)(uint64_t runtimeOffset, int libOrdinal, uint8_t type, const char* symbolName,
140 bool weakImport, bool lazyBind, uint64_t addend, bool& stop),
141 void (^strongHandler)(const char* symbolName)) const;
142 void forEachChainedFixupTarget(Diagnostics& diag, void (^callback)(int libOrdinal, const char* symbolName, uint64_t addend, bool weakImport, bool& stop)) const;
143 void forEachRebase(Diagnostics& diag, void (^handler)(const char* opcodeName, const LinkEditInfo& leInfo, const SegmentInfo segments[],
144 bool segIndexSet, uint32_t pointerSize, uint8_t segmentIndex, uint64_t segmentOffset, Rebase kind, bool& stop)) const;
145 void forEachBind(Diagnostics& diag, void (^handler)(const char* opcodeName, const LinkEditInfo& leInfo, const SegmentInfo segments[],
146 bool segIndexSet, bool libraryOrdinalSet, uint32_t dylibCount, int libOrdinal,
147 uint32_t pointerSize, uint8_t segmentIndex, uint64_t segmentOffset,
148 uint8_t type, const char* symbolName, bool weakImport, bool lazyBind, uint64_t addend, bool& stop),
149 void (^strongHandler)(const char* symbolName)) const;
150 bool canBePlacedInDyldCache(const char* path, void (^failureReason)(const char*)) const;
151 bool canHavePrecomputedDlopenClosure(const char* path, void (^failureReason)(const char*)) const;
152 #if BUILDING_APP_CACHE_UTIL
153 bool canBePlacedInKernelCollection(const char* path, void (^failureReason)(const char*)) const;
154 #endif
155 bool usesClassicRelocationsInKernelCollection() const;
156 uint32_t loadCommandsFreeSpace() const;
157 bool hasStompedLazyOpcodes() const;
158
159 #if DEBUG
160 void validateDyldCacheDylib(Diagnostics& diag, const char* path) const;
161 #endif
162 void withChainStarts(Diagnostics& diag, uint64_t startsStructOffsetHint, void (^callback)(const dyld_chained_starts_in_image*)) const;
163 uint64_t chainStartsOffset() const;
164 uint16_t chainedPointerFormat() const;
165 static uint16_t chainedPointerFormat(const dyld_chained_fixups_header* chainHeader);
166 bool hasUnalignedPointerFixups() const;
167 const dyld_chained_fixups_header* chainedFixupsHeader() const;
168 bool hasFirmwareChainStarts(uint16_t* pointerFormat, uint32_t* startsCount, const uint32_t** starts) const;
169 bool isOSBinary(int fd, uint64_t sliceOffset, uint64_t sliceSize) const; // checks if binary is codesigned to be part of the OS
170 static bool sliceIsOSBinary(int fd, uint64_t sliceOffset, uint64_t sliceSize);
171
172 const MachOAnalyzer* remapIfZeroFill(Diagnostics& diag, const closure::FileSystem& fileSystem, closure::LoadedFileInfo& info) const;
173
174 bool markNeverUnload(Diagnostics &diag) const;
175
176 struct ObjCInfo {
177 uint32_t selRefCount;
178 uint32_t classDefCount;
179 uint32_t protocolDefCount;
180 };
181 ObjCInfo getObjCInfo() const;
182
183 // This optionally caches a list of sections for lookup
184 struct SectionCache {
185 private:
186 SectionInfo buffer[2];
187
188 public:
189 SectionCache(const MachOAnalyzer* ma) : ma(ma) { }
190
191 bool findSectionForVMAddr(uint64_t vmAddr, bool (^sectionHandler)(const SectionInfo& sectionInfo));
192
193 const MachOAnalyzer* ma = nullptr;
194 dyld3::OverflowSafeArray<SectionInfo> sectionInfos = { buffer, sizeof(buffer) / sizeof(buffer[0]) };
195 };
196
197 struct ObjCClassInfo {
198 // These fields are all present on the objc_class_t struct
199 uint64_t isaVMAddr = 0;
200 uint64_t superclassVMAddr = 0;
201 //uint64_t methodCacheBuckets;
202 uint64_t methodCacheVMAddr = 0;
203 uint64_t dataVMAddr = 0;
204
205 // This field is only present if this is a Swift object, ie, has the Swift
206 // fast bits set
207 uint32_t swiftClassFlags = 0;
208
209 // These are taken from the low bits of the dataVMAddr value
210 bool isSwiftLegacy = false;
211 bool isSwiftStable = false;
212
213 // Cache the data to convert vmAddr's
214 MachOAnalyzer::VMAddrConverter vmAddrConverter;
215
216 // These are from the class_ro_t which data points to
217 enum class ReadOnlyDataField {
218 name,
219 baseProtocols,
220 baseMethods,
221 baseProperties,
222 flags
223 };
224
225 uint64_t getReadOnlyDataField(ReadOnlyDataField field, uint32_t pointerSize) const;
226 uint64_t nameVMAddr(uint32_t pointerSize) const {
227 return getReadOnlyDataField(ReadOnlyDataField::name, pointerSize);
228 }
229 uint64_t baseProtocolsVMAddr(uint32_t pointerSize) const {
230 return getReadOnlyDataField(ReadOnlyDataField::baseProtocols, pointerSize);
231 }
232 uint64_t baseMethodsVMAddr(uint32_t pointerSize) const {
233 return getReadOnlyDataField(ReadOnlyDataField::baseMethods, pointerSize);
234 }
235 uint64_t basePropertiesVMAddr(uint32_t pointerSize) const {
236 return getReadOnlyDataField(ReadOnlyDataField::baseProperties, pointerSize);
237 }
238 uint64_t flags(uint32_t pointerSize) const {
239 return getReadOnlyDataField(ReadOnlyDataField::flags, pointerSize);
240 }
241
242 // These are embedded in the Mach-O itself by the compiler
243 enum FastDataBits {
244 FAST_IS_SWIFT_LEGACY = 0x1,
245 FAST_IS_SWIFT_STABLE = 0x2
246 };
247
248 // These are embedded by the Swift compiler in the swiftClassFlags field
249 enum SwiftClassFlags {
250 isSwiftPreStableABI = 0x1
251 };
252
253 // Note this is taken from the objc runtime
254 bool isUnfixedBackwardDeployingStableSwift() const {
255 // Only classes marked as Swift legacy need apply.
256 if (!isSwiftLegacy) return false;
257
258 // Check the true legacy vs stable distinguisher.
259 // The low bit of Swift's ClassFlags is SET for true legacy
260 // and UNSET for stable pretending to be legacy.
261 bool isActuallySwiftLegacy = (swiftClassFlags & isSwiftPreStableABI) != 0;
262 return !isActuallySwiftLegacy;
263 }
264 };
265
266 struct ObjCMethodList {
267 // This matches the bits in the objc runtime
268 enum : uint32_t {
269 methodListIsUniqued = 0x1,
270 methodListIsSorted = 0x2,
271
272 // The size is bits 2 through 16 of the entsize field
273 // The low 2 bits are uniqued/sorted as above. The upper 16-bits
274 // are reserved for other flags
275 methodListSizeMask = 0x0000FFFC
276 };
277 };
278
279 struct ObjCImageInfo {
280 uint32_t version;
281 uint32_t flags;
282
283 // FIXME: Put this somewhere objc can see it.
284 enum : uint32_t {
285 dyldPreoptimized = 1 << 7
286 };
287 };
288
289 struct ObjCMethod {
290 uint64_t nameVMAddr; // & SEL
291 uint64_t typesVMAddr; // & const char *
292 uint64_t impVMAddr; // & IMP
293
294 // We also need to know where the reference to the nameVMAddr was
295 // This is so that we know how to rebind that location
296 uint64_t nameLocationVMAddr;
297 };
298
299 struct ObjCProperty {
300 uint64_t nameVMAddr; // & const char *
301 uint64_t attributesVMAddr; // & const char *
302 };
303
304 struct ObjCCategory {
305 uint64_t nameVMAddr;
306 uint64_t clsVMAddr;
307 uint64_t instanceMethodsVMAddr;
308 uint64_t classMethodsVMAddr;
309 uint64_t protocolsVMAddr;
310 uint64_t instancePropertiesVMAddr;
311 };
312
313 struct ObjCProtocol {
314 uint64_t isaVMAddr;
315 uint64_t nameVMAddr;
316 uint64_t protocolsVMAddr;
317 uint64_t instanceMethodsVMAddr;
318 uint64_t classMethodsVMAddr;
319 uint64_t optionalInstanceMethodsVMAddr;
320 uint64_t optionalClassMethodsVMAddr;
321 //uint64_t instancePropertiesVMAddr;
322 //uint32_t size;
323 //uint32_t flags;
324 // Fields below this point are not always present on disk.
325 //uint64_t extendedMethodTypesVMAddr;
326 //uint64_t demangledNameVMAddr;
327 //uint64_t classPropertiesVMAddr;
328 };
329
330 enum class PrintableStringResult {
331 CanPrint,
332 FairPlayEncrypted,
333 ProtectedSection,
334 UnknownSection
335 };
336
337 const char* getPrintableString(uint64_t stringVMAddr, PrintableStringResult& result,
338 SectionCache* sectionCache = nullptr,
339 bool (^sectionHandler)(const SectionInfo& sectionInfo) = nullptr) const;
340
341 void parseObjCClass(Diagnostics& diag, const VMAddrConverter& vmAddrConverter,
342 uint64_t classVMAddr,
343 void (^handler)(Diagnostics& diag,
344 uint64_t classSuperclassVMAddr,
345 uint64_t classDataVMAddr,
346 const ObjCClassInfo& objcClass)) const;
347
348 void forEachObjCClass(Diagnostics& diag, const VMAddrConverter& vmAddrConverter,
349 void (^handler)(Diagnostics& diag, uint64_t classVMAddr,
350 uint64_t classSuperclassVMAddr, uint64_t classDataVMAddr,
351 const ObjCClassInfo& objcClass, bool isMetaClass)) const;
352
353 void forEachObjCCategory(Diagnostics& diag, const VMAddrConverter& vmAddrConverter,
354 void (^handler)(Diagnostics& diag, uint64_t categoryVMAddr,
355 const dyld3::MachOAnalyzer::ObjCCategory& objcCategory)) const;
356
357 // lists all Protocols defined in the image
358 void forEachObjCProtocol(Diagnostics& diag, const VMAddrConverter& vmAddrConverter,
359 void (^handler)(Diagnostics& diag, uint64_t protocolVMAddr,
360 const dyld3::MachOAnalyzer::ObjCProtocol& objCProtocol)) const;
361
362 // Walk a method list starting from its vmAddr.
363 // Note, classes, categories, protocols, etc, all share the same method list struture so can all use this.
364 void forEachObjCMethod(uint64_t methodListVMAddr, const VMAddrConverter& vmAddrConverter,
365 void (^handler)(uint64_t methodVMAddr, const ObjCMethod& method),
366 bool* isRelativeMethodList = nullptr) const;
367
368 void forEachObjCProperty(uint64_t propertyListVMAddr, const VMAddrConverter& vmAddrConverter,
369 void (^handler)(uint64_t propertyVMAddr, const ObjCProperty& property)) const;
370
371 // lists all Protocols on a protocol_list_t
372 void forEachObjCProtocol(uint64_t protocolListVMAddr, const VMAddrConverter& vmAddrConverter,
373 void (^handler)(uint64_t protocolRefVMAddr, const ObjCProtocol& protocol)) const;
374
375 void forEachObjCSelectorReference(Diagnostics& diag, const VMAddrConverter& vmAddrConverter,
376 void (^handler)(uint64_t selRefVMAddr, uint64_t selRefTargetVMAddr)) const;
377
378 void forEachObjCMethodName(void (^handler)(const char* methodName)) const;
379
380 bool hasObjCMessageReferences() const;
381
382 const ObjCImageInfo* objcImageInfo() const;
383
384 void forEachWeakDef(Diagnostics& diag, void (^handler)(const char* symbolName, uint64_t imageOffset, bool isFromExportTrie)) const;
385
386 private:
387
388 struct SegmentStuff
389 {
390 uint64_t fileOffset;
391 uint64_t fileSize;
392 uint64_t writable : 1,
393 executable : 1,
394 textRelocsAllowed : 1, // segment supports text relocs (i386 only)
395 segSize : 61;
396 };
397
398 enum class Malformed { linkeditOrder, linkeditAlignment, linkeditPermissions, dyldInfoAndlocalRelocs, segmentOrder,
399 textPermissions, executableData, writableData, codeSigAlignment, sectionsAddrRangeWithinSegment };
400 bool enforceFormat(Malformed) const;
401
402 const uint8_t* getContentForVMAddr(const LayoutInfo& info, uint64_t vmAddr) const;
403 bool validLoadCommands(Diagnostics& diag, const char* path, size_t fileLen) const;
404 bool validEmbeddedPaths(Diagnostics& diag, Platform platform, const char* path) const;
405 bool validSegments(Diagnostics& diag, const char* path, size_t fileLen) const;
406 bool validLinkedit(Diagnostics& diag, const char* path) const;
407 bool validLinkeditLayout(Diagnostics& diag, const char* path) const;
408 bool validRebaseInfo(Diagnostics& diag, const char* path) const;
409 bool validBindInfo(Diagnostics& diag, const char* path) const;
410 bool validMain(Diagnostics& diag, const char* path) const;
411 bool validChainedFixupsInfo(Diagnostics& diag, const char* path) const;
412 bool validChainedFixupsInfoOldArm64e(Diagnostics& diag, const char* path) const;
413
414 bool invalidRebaseState(Diagnostics& diag, const char* opcodeName, const char* path, const LinkEditInfo& leInfo, const SegmentInfo segments[],
415 bool segIndexSet, uint32_t pointerSize, uint8_t segmentIndex, uint64_t segmentOffset, Rebase kind) const;
416 bool invalidBindState(Diagnostics& diag, const char* opcodeName, const char* path, const LinkEditInfo& leInfo, const SegmentInfo segments[],
417 bool segIndexSet, bool libraryOrdinalSet, uint32_t dylibCount, int libOrdinal, uint32_t pointerSize,
418 uint8_t segmentIndex, uint64_t segmentOffset, uint8_t type, const char* symbolName) const;
419 bool doLocalReloc(Diagnostics& diag, uint32_t r_address, bool& stop, void (^callback)(uint32_t dataSegIndex, uint64_t dataSegOffset, uint8_t type, bool& stop)) const;
420 uint8_t relocPointerType() const;
421 int libOrdinalFromDesc(uint16_t n_desc) const;
422 bool doExternalReloc(Diagnostics& diag, uint32_t r_address, uint32_t r_symbolnum, LinkEditInfo& leInfo, bool& stop,
423 void (^callback)(uint32_t dataSegIndex, uint64_t dataSegOffset, uint8_t type, int libOrdinal,
424 uint64_t addend, const char* symbolName, bool weakImport, bool lazy, bool& stop)) const;
425
426 void getAllSegmentsInfos(Diagnostics& diag, SegmentInfo segments[]) const;
427 bool segmentHasTextRelocs(uint32_t segIndex) const;
428 uint64_t localRelocBaseAddress(const SegmentInfo segmentsInfos[], uint32_t segCount) const;
429 uint64_t externalRelocBaseAddress(const SegmentInfo segmentsInfos[], uint32_t segCount) const;
430 bool segIndexAndOffsetForAddress(uint64_t addr, const SegmentInfo segmentsInfos[], uint32_t segCount, uint32_t& segIndex, uint64_t& segOffset) const;
431 void parseOrgArm64eChainedFixups(Diagnostics& diag, void (^targetCount)(uint32_t totalTargets, bool& stop),
432 void (^addTarget)(const LinkEditInfo& leInfo, const SegmentInfo segments[], bool libraryOrdinalSet, uint32_t dylibCount, int libOrdinal, uint8_t type, const char* symbolName, uint64_t addend, bool weakImport, bool& stop),
433 void (^addChainStart)(const LinkEditInfo& leInfo, const SegmentInfo segments[], uint8_t segmentIndex, bool segIndexSet, uint64_t segmentOffset, uint16_t format, bool& stop)) const;
434 bool contentIsRegularStub(const uint8_t* helperContent) const;
435 void recurseTrie(Diagnostics& diag, const uint8_t* const start, const uint8_t* p, const uint8_t* const end,
436 OverflowSafeArray<char>& cummulativeString, int curStrOffset, bool& stop, MachOAnalyzer::ExportsCallback callback) const;
437 void analyzeSegmentsLayout(uint64_t& vmSpace, bool& hasZeroFill) const;
438
439 };
440
441
442 } // namespace dyld3
443
444 #endif /* MachOAnalyzer_h */