OLD | NEW |
(Empty) | |
| 1 // -*- mode: ObjC -*- |
| 2 |
| 3 // This file is part of class-dump, a utility for examining the Objective-C seg
ment of Mach-O files. |
| 4 // Copyright (C) 1997-1998, 2000-2001, 2004-2010 Steve Nygard. |
| 5 |
| 6 #import "CDMachOFile.h" |
| 7 |
| 8 #include <mach-o/arch.h> |
| 9 #include <mach-o/loader.h> |
| 10 #include <mach-o/fat.h> |
| 11 |
| 12 #import "CDDataCursor.h" |
| 13 #import "CDFatFile.h" |
| 14 #import "CDLoadCommand.h" |
| 15 #import "CDLCDyldInfo.h" |
| 16 #import "CDLCDylib.h" |
| 17 #import "CDLCDynamicSymbolTable.h" |
| 18 #import "CDLCEncryptionInfo.h" |
| 19 #import "CDLCRunPath.h" |
| 20 #import "CDLCSegment.h" |
| 21 #import "CDLCSegment64.h" |
| 22 #import "CDLCSymbolTable.h" |
| 23 #import "CDLCUUID.h" |
| 24 #import "CDObjectiveCProcessor.h" |
| 25 #import "CDSection.h" |
| 26 #import "CDSymbol.h" |
| 27 #import "CDRelocationInfo.h" |
| 28 #import "CDSearchPathState.h" |
| 29 |
| 30 NSString *CDMagicNumberString(uint32_t magic) |
| 31 { |
| 32 switch (magic) { |
| 33 case MH_MAGIC: return @"MH_MAGIC"; |
| 34 case MH_CIGAM: return @"MH_CIGAM"; |
| 35 case MH_MAGIC_64: return @"MH_MAGIC_64"; |
| 36 case MH_CIGAM_64: return @"MH_CIGAM_64"; |
| 37 } |
| 38 |
| 39 return [NSString stringWithFormat:@"0x%08x", magic]; |
| 40 } |
| 41 |
| 42 static BOOL debug = NO; |
| 43 |
| 44 @implementation CDMachOFile |
| 45 |
| 46 - (id)initWithData:(NSData *)someData offset:(NSUInteger)anOffset filename:(NSSt
ring *)aFilename searchPathState:(CDSearchPathState *)aSearchPathState; |
| 47 { |
| 48 if ([super initWithData:someData offset:anOffset filename:aFilename searchPa
thState:aSearchPathState] == nil) |
| 49 return nil; |
| 50 |
| 51 byteOrder = CDByteOrderLittleEndian; |
| 52 loadCommands = [[NSMutableArray alloc] init]; |
| 53 segments = [[NSMutableArray alloc] init]; |
| 54 symbolTable = nil; |
| 55 dynamicSymbolTable = nil; |
| 56 dyldInfo = nil; |
| 57 runPaths = [[NSMutableArray alloc] init]; |
| 58 _flags.uses64BitABI = NO; |
| 59 |
| 60 return self; |
| 61 } |
| 62 |
| 63 - (void)_readLoadCommands:(CDDataCursor *)cursor count:(uint32_t)count; |
| 64 { |
| 65 uint32_t index; |
| 66 |
| 67 for (index = 0; index < count; index++) { |
| 68 id loadCommand; |
| 69 |
| 70 loadCommand = [CDLoadCommand loadCommandWithDataCursor:cursor machOFile:
self]; |
| 71 if (loadCommand != nil) { |
| 72 [loadCommands addObject:loadCommand]; |
| 73 |
| 74 if ([loadCommand isKindOfClass:[CDLCSegment class]]) |
| 75 [segments addObject:loadCommand]; |
| 76 |
| 77 if ([loadCommand isKindOfClass:[CDLCSymbolTable class]]) |
| 78 [self setSymbolTable:(CDLCSymbolTable *)loadCommand]; |
| 79 else if ([loadCommand isKindOfClass:[CDLCDynamicSymbolTable class]]) |
| 80 [self setDynamicSymbolTable:(CDLCDynamicSymbolTable *)loadComman
d]; |
| 81 else if ([loadCommand isKindOfClass:[CDLCDyldInfo class]]) |
| 82 [self setDyldInfo:(CDLCDyldInfo *)loadCommand]; |
| 83 else if ([loadCommand isKindOfClass:[CDLCRunPath class]]) |
| 84 [runPaths addObject:[(CDLCRunPath *)loadCommand resolvedRunPath]
]; |
| 85 } |
| 86 //NSLog(@"loadCommand: %@", loadCommand); |
| 87 } |
| 88 } |
| 89 |
| 90 - (void)dealloc; |
| 91 { |
| 92 [loadCommands release]; // These all reference data, so release them first..
. Should they just retain data themselves? |
| 93 [segments release]; |
| 94 [symbolTable release]; |
| 95 [dynamicSymbolTable release]; |
| 96 [dyldInfo release]; |
| 97 [runPaths release]; |
| 98 |
| 99 [super dealloc]; |
| 100 } |
| 101 |
| 102 - (CDByteOrder)byteOrder; |
| 103 { |
| 104 return byteOrder; |
| 105 } |
| 106 |
| 107 - (CDMachOFile *)machOFileWithArch:(CDArch)arch; |
| 108 { |
| 109 if ([self cputype] == arch.cputype) |
| 110 return self; |
| 111 |
| 112 return nil; |
| 113 } |
| 114 |
| 115 - (uint32_t)magic; |
| 116 { |
| 117 // Implement in subclasses. |
| 118 return 0; |
| 119 } |
| 120 |
| 121 - (cpu_type_t)cputype; |
| 122 { |
| 123 // Implement in subclasses. |
| 124 return 0; |
| 125 } |
| 126 |
| 127 - (cpu_subtype_t)cpusubtype; |
| 128 { |
| 129 // Implement in subclasses. |
| 130 return 0; |
| 131 } |
| 132 |
| 133 // Well... only the arch bits it knows about. |
| 134 - (cpu_type_t)cputypePlusArchBits; |
| 135 { |
| 136 if ([self uses64BitABI]) |
| 137 return [self cputype] | CPU_ARCH_ABI64; |
| 138 |
| 139 return [self cputype]; |
| 140 } |
| 141 |
| 142 #if 0 |
| 143 - (const NXArchInfo *)archInfo; |
| 144 { |
| 145 const NXArchInfo *archInfo; |
| 146 |
| 147 if ([self uses64BitABI]) { |
| 148 archInfo = NXGetArchInfoFromCpuType([self cputype] | CPU_ARCH_ABI64, [se
lf cpusubtype]); |
| 149 } else { |
| 150 archInfo = NXGetArchInfoFromCpuType([self cputype], [self cpusubtype]); |
| 151 } |
| 152 |
| 153 return archInfo; |
| 154 } |
| 155 #endif |
| 156 |
| 157 - (uint32_t)filetype; |
| 158 { |
| 159 // Implement in subclasses. |
| 160 return 0; |
| 161 } |
| 162 |
| 163 - (uint32_t)flags; |
| 164 { |
| 165 // Implement in subclasses. |
| 166 return 0; |
| 167 } |
| 168 |
| 169 - (NSArray *)loadCommands; |
| 170 { |
| 171 return loadCommands; |
| 172 } |
| 173 |
| 174 - (NSArray *)dylibLoadCommands; |
| 175 { |
| 176 NSMutableArray *dylibLoadCommands = [NSMutableArray array]; |
| 177 for (id loadCommand in loadCommands) { |
| 178 if ([loadCommand isKindOfClass:[CDLCDylib class]]) |
| 179 [dylibLoadCommands addObject:loadCommand]; |
| 180 } |
| 181 return dylibLoadCommands; |
| 182 } |
| 183 |
| 184 - (NSArray *)segments; |
| 185 { |
| 186 return segments; |
| 187 } |
| 188 |
| 189 @synthesize symbolTable; |
| 190 @synthesize dynamicSymbolTable; |
| 191 @synthesize dyldInfo; |
| 192 |
| 193 - (BOOL)uses64BitABI; |
| 194 { |
| 195 return _flags.uses64BitABI; |
| 196 } |
| 197 |
| 198 - (NSString *)filetypeDescription; |
| 199 { |
| 200 switch ([self filetype]) { |
| 201 case MH_OBJECT: return @"OBJECT"; |
| 202 case MH_EXECUTE: return @"EXECUTE"; |
| 203 case MH_FVMLIB: return @"FVMLIB"; |
| 204 case MH_CORE: return @"CORE"; |
| 205 case MH_PRELOAD: return @"PRELOAD"; |
| 206 case MH_DYLIB: return @"DYLIB"; |
| 207 case MH_DYLINKER: return @"DYLINKER"; |
| 208 case MH_BUNDLE: return @"BUNDLE"; |
| 209 case MH_DYLIB_STUB: return @"DYLIB_STUB"; |
| 210 case MH_DSYM: return @"DSYM"; |
| 211 default: |
| 212 break; |
| 213 } |
| 214 |
| 215 return nil; |
| 216 } |
| 217 |
| 218 - (NSString *)flagDescription; |
| 219 { |
| 220 NSMutableArray *setFlags; |
| 221 uint32_t flags; |
| 222 |
| 223 setFlags = [NSMutableArray array]; |
| 224 flags = [self flags]; |
| 225 if (flags & MH_NOUNDEFS) |
| 226 [setFlags addObject:@"NOUNDEFS"]; |
| 227 if (flags & MH_INCRLINK) |
| 228 [setFlags addObject:@"INCRLINK"]; |
| 229 if (flags & MH_DYLDLINK) |
| 230 [setFlags addObject:@"DYLDLINK"]; |
| 231 if (flags & MH_BINDATLOAD) |
| 232 [setFlags addObject:@"BINDATLOAD"]; |
| 233 if (flags & MH_PREBOUND) |
| 234 [setFlags addObject:@"PREBOUND"]; |
| 235 if (flags & MH_SPLIT_SEGS) |
| 236 [setFlags addObject:@"SPLIT_SEGS"]; |
| 237 if (flags & MH_LAZY_INIT) |
| 238 [setFlags addObject:@"LAZY_INIT"]; |
| 239 if (flags & MH_TWOLEVEL) |
| 240 [setFlags addObject:@"TWOLEVEL"]; |
| 241 if (flags & MH_FORCE_FLAT) |
| 242 [setFlags addObject:@"FORCE_FLAT"]; |
| 243 if (flags & MH_NOMULTIDEFS) |
| 244 [setFlags addObject:@"NOMULTIDEFS"]; |
| 245 if (flags & MH_NOFIXPREBINDING) |
| 246 [setFlags addObject:@"NOFIXPREBINDING"]; |
| 247 if (flags & MH_PREBINDABLE) |
| 248 [setFlags addObject:@"PREBINDABLE"]; |
| 249 if (flags & MH_ALLMODSBOUND) |
| 250 [setFlags addObject:@"ALLMODSBOUND"]; |
| 251 if (flags & MH_SUBSECTIONS_VIA_SYMBOLS) |
| 252 [setFlags addObject:@"SUBSECTIONS_VIA_SYMBOLS"]; |
| 253 if (flags & MH_CANONICAL) |
| 254 [setFlags addObject:@"CANONICAL"]; |
| 255 if (flags & MH_WEAK_DEFINES) |
| 256 [setFlags addObject:@"WEAK_DEFINES"]; |
| 257 if (flags & MH_BINDS_TO_WEAK) |
| 258 [setFlags addObject:@"BINDS_TO_WEAK"]; |
| 259 if (flags & MH_ALLOW_STACK_EXECUTION) |
| 260 [setFlags addObject:@"ALLOW_STACK_EXECUTION"]; |
| 261 #if 1 |
| 262 // 10.5 only, but I'm still using the 10.4 sdk. |
| 263 if (flags & MH_ROOT_SAFE) |
| 264 [setFlags addObject:@"ROOT_SAFE"]; |
| 265 if (flags & MH_SETUID_SAFE) |
| 266 [setFlags addObject:@"SETUID_SAFE"]; |
| 267 if (flags & MH_NO_REEXPORTED_DYLIBS) |
| 268 [setFlags addObject:@"NO_REEXPORTED_DYLIBS"]; |
| 269 if (flags & MH_PIE) |
| 270 [setFlags addObject:@"PIE"]; |
| 271 #endif |
| 272 |
| 273 return [setFlags componentsJoinedByString:@" "]; |
| 274 } |
| 275 |
| 276 - (CDLCDylib *)dylibIdentifier; |
| 277 { |
| 278 for (CDLoadCommand *loadCommand in loadCommands) { |
| 279 if ([loadCommand cmd] == LC_ID_DYLIB) |
| 280 return (CDLCDylib *)loadCommand; |
| 281 } |
| 282 |
| 283 return nil; |
| 284 } |
| 285 |
| 286 - (CDLCSegment *)segmentWithName:(NSString *)segmentName; |
| 287 { |
| 288 for (id loadCommand in loadCommands) { |
| 289 if ([loadCommand isKindOfClass:[CDLCSegment class]] && [[loadCommand nam
e] isEqual:segmentName]) { |
| 290 return loadCommand; |
| 291 } |
| 292 } |
| 293 |
| 294 return nil; |
| 295 } |
| 296 |
| 297 - (CDLCSegment *)segmentContainingAddress:(NSUInteger)address; |
| 298 { |
| 299 for (id loadCommand in loadCommands) { |
| 300 if ([loadCommand isKindOfClass:[CDLCSegment class]] && [loadCommand cont
ainsAddress:address]) { |
| 301 return loadCommand; |
| 302 } |
| 303 } |
| 304 |
| 305 return nil; |
| 306 } |
| 307 |
| 308 - (void)showWarning:(NSString *)aWarning; |
| 309 { |
| 310 NSLog(@"Warning: %@", aWarning); |
| 311 } |
| 312 |
| 313 - (NSString *)stringAtAddress:(NSUInteger)address; |
| 314 { |
| 315 CDLCSegment *segment; |
| 316 |
| 317 NSUInteger anOffset; |
| 318 const void *ptr; |
| 319 |
| 320 if (address == 0) |
| 321 return nil; |
| 322 |
| 323 segment = [self segmentContainingAddress:address]; |
| 324 if (segment == nil) { |
| 325 NSLog(@"Error: Cannot find offset for address 0x%08x in dataOffsetForAdd
ress:", address); |
| 326 exit(5); |
| 327 return nil; |
| 328 } |
| 329 |
| 330 if ([segment isProtected]) { |
| 331 NSData *d2; |
| 332 NSUInteger d2Offset; |
| 333 |
| 334 d2 = [segment decryptedData]; |
| 335 d2Offset = [segment segmentOffsetForAddress:address]; |
| 336 if (d2Offset == 0) |
| 337 return nil; |
| 338 |
| 339 ptr = [d2 bytes] + d2Offset; |
| 340 return [[[NSString alloc] initWithBytes:ptr length:strlen(ptr) encoding:
NSASCIIStringEncoding] autorelease]; |
| 341 } |
| 342 |
| 343 anOffset = [self dataOffsetForAddress:address]; |
| 344 if (anOffset == 0) |
| 345 return nil; |
| 346 |
| 347 ptr = [data bytes] + anOffset; |
| 348 |
| 349 return [[[NSString alloc] initWithBytes:ptr length:strlen(ptr) encoding:NSAS
CIIStringEncoding] autorelease]; |
| 350 } |
| 351 |
| 352 - (const void *)machODataBytes; |
| 353 { |
| 354 return [data bytes] + offset; |
| 355 } |
| 356 |
| 357 - (NSUInteger)dataOffsetForAddress:(NSUInteger)address; |
| 358 { |
| 359 return [self dataOffsetForAddress:address segmentName:nil]; |
| 360 } |
| 361 |
| 362 - (NSUInteger)dataOffsetForAddress:(NSUInteger)address segmentName:(NSString *)a
SegmentName; |
| 363 { |
| 364 CDLCSegment *segment; |
| 365 |
| 366 if (address == 0) |
| 367 return 0; |
| 368 |
| 369 segment = [self segmentContainingAddress:address]; |
| 370 if (segment == nil) { |
| 371 NSLog(@"Error: Cannot find offset for address 0x%08lx in dataOffsetForAd
dress:", address); |
| 372 exit(5); |
| 373 return 0; |
| 374 } |
| 375 |
| 376 if (aSegmentName != nil && [[segment name] isEqual:aSegmentName] == NO) { |
| 377 // This can happen with the symtab in a module. In one case, the symtab
is in __DATA, __bss, in the zero filled area. |
| 378 // i.e. section offset is 0. |
| 379 if (debug) NSLog(@"Note: Couldn't find address in specified segment (%08
lx, %@)", address, aSegmentName); |
| 380 //NSLog(@"\tsegment was: %@", segment); |
| 381 //exit(5); |
| 382 return 0; |
| 383 } |
| 384 |
| 385 if ([segment isProtected]) { |
| 386 NSLog(@"Error: Segment is protected."); |
| 387 exit(5); |
| 388 } |
| 389 |
| 390 #if 0 |
| 391 NSLog(@"---------->"); |
| 392 NSLog(@"segment is: %@", segment); |
| 393 NSLog(@"address: 0x%08x", address); |
| 394 NSLog(@"CDFile offset: 0x%08x", offset); |
| 395 NSLog(@"file off for address: 0x%08x", [segment fileOffsetForAddress:address
]); |
| 396 NSLog(@"data offset: 0x%08x", offset + [segment fileOffsetForAddress:ad
dress]); |
| 397 NSLog(@"<----------"); |
| 398 #endif |
| 399 return offset + [segment fileOffsetForAddress:address]; |
| 400 } |
| 401 |
| 402 - (const void *)bytes; |
| 403 { |
| 404 return [data bytes]; |
| 405 } |
| 406 |
| 407 - (const void *)bytesAtOffset:(NSUInteger)anOffset; |
| 408 { |
| 409 return [data bytes] + anOffset; |
| 410 } |
| 411 |
| 412 - (NSString *)importBaseName; |
| 413 { |
| 414 if ([self filetype] == MH_DYLIB) { |
| 415 NSString *str; |
| 416 |
| 417 str = [filename lastPathComponent]; |
| 418 if ([str hasPrefix:@"lib"]) |
| 419 str = [[[str substringFromIndex:3] componentsSeparatedByString:@"."]
objectAtIndex:0]; |
| 420 |
| 421 return str; |
| 422 } |
| 423 |
| 424 return nil; |
| 425 } |
| 426 |
| 427 - (BOOL)isEncrypted; |
| 428 { |
| 429 for (CDLoadCommand *loadCommand in loadCommands) { |
| 430 if ([loadCommand isKindOfClass:[CDLCEncryptionInfo class]] && [(CDLCEncr
yptionInfo *)loadCommand isEncrypted]) { |
| 431 return YES; |
| 432 } |
| 433 } |
| 434 |
| 435 return NO; |
| 436 } |
| 437 |
| 438 - (BOOL)hasProtectedSegments; |
| 439 { |
| 440 for (CDLoadCommand *loadCommand in loadCommands) { |
| 441 if ([loadCommand isKindOfClass:[CDLCSegment class]] && [(CDLCSegment *)l
oadCommand isProtected]) |
| 442 return YES; |
| 443 } |
| 444 |
| 445 return NO; |
| 446 } |
| 447 |
| 448 - (BOOL)canDecryptAllSegments; |
| 449 { |
| 450 for (CDLoadCommand *loadCommand in loadCommands) { |
| 451 if ([loadCommand isKindOfClass:[CDLCSegment class]] && [(CDLCSegment *)l
oadCommand canDecrypt] == NO) |
| 452 return NO; |
| 453 } |
| 454 |
| 455 return YES; |
| 456 } |
| 457 |
| 458 - (NSString *)loadCommandString:(BOOL)isVerbose; |
| 459 { |
| 460 NSMutableString *resultString; |
| 461 unsigned int count, index; |
| 462 |
| 463 resultString = [NSMutableString string]; |
| 464 count = [loadCommands count]; |
| 465 for (index = 0; index < count; index++) { |
| 466 CDLoadCommand *loadCommand; |
| 467 |
| 468 [resultString appendFormat:@"Load command %u\n", index]; |
| 469 loadCommand = [loadCommands objectAtIndex:index]; |
| 470 [loadCommand appendToString:resultString verbose:isVerbose]; |
| 471 [resultString appendString:@"\n"]; |
| 472 } |
| 473 |
| 474 return resultString; |
| 475 } |
| 476 |
| 477 - (NSString *)headerString:(BOOL)isVerbose; |
| 478 { |
| 479 NSMutableString *resultString; |
| 480 |
| 481 resultString = [NSMutableString string]; |
| 482 [resultString appendString:@"Mach header\n"]; |
| 483 [resultString appendString:@" magic cputype cpusubtype filetype ncmds
sizeofcmds flags\n"]; |
| 484 // Grr, %11@ doesn't work. |
| 485 if (isVerbose) |
| 486 [resultString appendFormat:@"%11@ %7@ %10u %8@ %5u %10u %@\n", |
| 487 CDMagicNumberString([self magic]), [self archName], [self
cpusubtype], |
| 488 [self filetypeDescription], [loadCommands count], 0, [self
flagDescription]]; |
| 489 else |
| 490 [resultString appendFormat:@" 0x%08x %7u %10u %8u %5u %10u 0x%08x\n", |
| 491 [self magic], [self cputype], [self cpusubtype], [self fil
etype], [loadCommands count], 0, [self flags]]; |
| 492 [resultString appendString:@"\n"]; |
| 493 |
| 494 return resultString; |
| 495 } |
| 496 |
| 497 - (NSString *)uuidString; |
| 498 { |
| 499 for (CDLoadCommand *loadCommand in loadCommands) |
| 500 if ([loadCommand isKindOfClass:[CDLCUUID class]]) |
| 501 return [(CDLCUUID*)loadCommand uuidString]; |
| 502 |
| 503 return @"N/A"; |
| 504 } |
| 505 |
| 506 // Must not return nil. |
| 507 - (NSString *)archName; |
| 508 { |
| 509 return CDNameForCPUType([self cputype], [self cpusubtype]); |
| 510 } |
| 511 |
| 512 - (NSString *)description; |
| 513 { |
| 514 return [NSString stringWithFormat:@"<%@:%p> magic: 0x%08x, cputype: %x, cpus
ubtype: %x, filetype: %d, ncmds: %d, sizeofcmds: %d, flags: 0x%x, uses64BitABI?
%d, filename: %@, data: %p, offset: %p", |
| 515 NSStringFromClass([self class]), self, |
| 516 [self magic], [self cputype], [self cpusubtype], [self file
type], [loadCommands count], 0, [self flags], _flags.uses64BitABI, |
| 517 filename, data, offset]; |
| 518 } |
| 519 |
| 520 - (Class)processorClass; |
| 521 { |
| 522 // Implement in subclasses |
| 523 return [CDObjectiveCProcessor class]; |
| 524 } |
| 525 |
| 526 - (void)logInfoForAddress:(NSUInteger)address; |
| 527 { |
| 528 if (address != 0) { |
| 529 CDLCSegment *segment; |
| 530 NSString *str; |
| 531 |
| 532 segment = [self segmentContainingAddress:address]; |
| 533 if (segment == nil) { |
| 534 NSLog(@"No segment contains address: %016lx", address); |
| 535 } else { |
| 536 CDSection *section; |
| 537 |
| 538 //NSLog(@"Found address %016lx in segment, sections= %@", address, [
segment sections]); |
| 539 section = [segment sectionContainingAddress:address]; |
| 540 if (section == nil) { |
| 541 NSLog(@"Found address %016lx in segment %@, but not in a section
", address, [segment name]); |
| 542 } else { |
| 543 NSLog(@"Found address %016lx in segment %@, section %@", address
, [segment name], [section sectionName]); |
| 544 } |
| 545 } |
| 546 |
| 547 str = [self stringAtAddress:address]; |
| 548 NSLog(@" address %016lx as a string: '%@' (length %lu)", address, s
tr, [str length]); |
| 549 NSLog(@" address %016lx data offset: %lu", address, [self dataOffse
tForAddress:address]); |
| 550 } |
| 551 } |
| 552 |
| 553 - (NSString *)externalClassNameForAddress:(NSUInteger)address; |
| 554 { |
| 555 CDRelocationInfo *rinfo; |
| 556 |
| 557 // Not for NSCFArray (NSMutableArray), NSSimpleAttributeDictionaryEnumerator
(NSEnumerator), NSSimpleAttributeDictionary (NSDictionary), etc. |
| 558 // It turns out NSMutableArray is in /System/Library/Frameworks/CoreFoundati
on.framework/Versions/A/CoreFoundation, so... |
| 559 // ... it's an undefined symbol, need to look it up. |
| 560 rinfo = [dynamicSymbolTable relocationEntryWithOffset:address - [symbolTable
baseAddress]]; |
| 561 //NSLog(@"rinfo: %@", rinfo); |
| 562 if (rinfo != nil) { |
| 563 CDSymbol *symbol; |
| 564 NSString *str; |
| 565 |
| 566 symbol = [[symbolTable symbols] objectAtIndex:rinfo.symbolnum]; |
| 567 //NSLog(@"symbol: %@", symbol); |
| 568 |
| 569 // Now we could use GET_LIBRARY_ORDINAL(), look up the the appropriate m
ach-o file (being sure to have loaded them even without -r), |
| 570 // look up the symbol in that mach-o file, get the address, look up the
class based on that address, and finally get the class name |
| 571 // from that. |
| 572 |
| 573 // Or, we could be lazy and take advantage of the fact that the class na
me we're after is in the symbol name: |
| 574 str = [symbol name]; |
| 575 if ([str hasPrefix:ObjCClassSymbolPrefix]) { |
| 576 return [str substringFromIndex:[ObjCClassSymbolPrefix length]]; |
| 577 } else { |
| 578 NSLog(@"Warning: Unknown prefix on symbol name... %@ (addr %lx)", st
r, address); |
| 579 return str; |
| 580 } |
| 581 } |
| 582 |
| 583 // This is fine, they might really be root objects. NSObject, NSProxy. |
| 584 return nil; |
| 585 } |
| 586 |
| 587 - (BOOL)hasRelocationEntryForAddress:(NSUInteger)address; |
| 588 { |
| 589 CDRelocationInfo *rinfo; |
| 590 |
| 591 rinfo = [dynamicSymbolTable relocationEntryWithOffset:address - [symbolTable
baseAddress]]; |
| 592 //NSLog(@"%s, rinfo= %@", _cmd, rinfo); |
| 593 return rinfo != nil; |
| 594 } |
| 595 |
| 596 - (BOOL)hasRelocationEntryForAddress2:(NSUInteger)address; |
| 597 { |
| 598 return [dyldInfo symbolNameForAddress:address] != nil; |
| 599 } |
| 600 |
| 601 - (NSString *)externalClassNameForAddress2:(NSUInteger)address; |
| 602 { |
| 603 NSString *str = [dyldInfo symbolNameForAddress:address]; |
| 604 |
| 605 if (str != nil) { |
| 606 if ([str hasPrefix:ObjCClassSymbolPrefix]) { |
| 607 return [str substringFromIndex:[ObjCClassSymbolPrefix length]]; |
| 608 } else { |
| 609 NSLog(@"Warning: Unknown prefix on symbol name... %@ (addr %lx)", st
r, address); |
| 610 return str; |
| 611 } |
| 612 } |
| 613 |
| 614 return nil; |
| 615 } |
| 616 |
| 617 - (BOOL)hasObjectiveC1Data; |
| 618 { |
| 619 return [self segmentWithName:@"__OBJC"] != nil; |
| 620 } |
| 621 |
| 622 - (BOOL)hasObjectiveC2Data; |
| 623 { |
| 624 // http://twitter.com/gparker/status/17962955683 |
| 625 return [[self segmentWithName:@"__DATA"] sectionWithName:@"__objc_imageinfo"
] != nil; |
| 626 } |
| 627 |
| 628 - (void)saveDeprotectedFileToPath:(NSString *)path; |
| 629 { |
| 630 NSMutableData *mdata; |
| 631 |
| 632 // Not going to handle fat files -- thin it first |
| 633 NSParameterAssert(offset == 0); |
| 634 |
| 635 mdata = [[NSMutableData alloc] initWithData:data]; |
| 636 for (CDLoadCommand *command in loadCommands) { |
| 637 if ([command isKindOfClass:[CDLCSegment class]]) { |
| 638 CDLCSegment *segment = (CDLCSegment *)command; |
| 639 |
| 640 if ([segment isProtected]) { |
| 641 NSData *decryptedData; |
| 642 NSRange range; |
| 643 uint32_t flags; |
| 644 NSUInteger flagOffset; |
| 645 |
| 646 NSLog(@"segment is protected: %@", segment); |
| 647 range.location = [segment fileoff]; |
| 648 range.length = [segment filesize]; |
| 649 |
| 650 decryptedData = [segment decryptedData]; |
| 651 NSParameterAssert([decryptedData length] == range.length); |
| 652 |
| 653 [mdata replaceBytesInRange:range withBytes:[decryptedData bytes]
]; |
| 654 if ([segment isKindOfClass:[CDLCSegment64 class]]) { |
| 655 flagOffset = [segment commandOffset] + offsetof(struct segme
nt_command_64, flags); |
| 656 } else { |
| 657 flagOffset = [segment commandOffset] + offsetof(struct segme
nt_command, flags); |
| 658 } |
| 659 |
| 660 // TODO (2009-07-10): Needs to be endian-neutral |
| 661 flags = OSReadLittleInt32([mdata mutableBytes], flagOffset); |
| 662 NSLog(@"old flags: %08x", flags); |
| 663 NSLog(@"segment flags: %08x", [segment flags]); |
| 664 flags &= ~SG_PROTECTED_VERSION_1; |
| 665 NSLog(@"new flags: %08x", flags); |
| 666 |
| 667 OSWriteLittleInt32([mdata mutableBytes], flagOffset, flags); |
| 668 } |
| 669 } |
| 670 } |
| 671 |
| 672 [mdata writeToFile:path atomically:NO]; |
| 673 |
| 674 [mdata release]; |
| 675 } |
| 676 |
| 677 - (NSArray *)runPaths; |
| 678 { |
| 679 return runPaths; |
| 680 } |
| 681 |
| 682 @end |
OLD | NEW |