X-Git-Url: https://git.saurik.com/ldid.git/blobdiff_plain/31ad673ba62d384fcdfa4d6f64d2ca328770da1d..4a57e66c94496a1343427266945b7592f1091936:/ldid.cpp diff --git a/ldid.cpp b/ldid.cpp index dc1902e..db72db8 100644 --- a/ldid.cpp +++ b/ldid.cpp @@ -1,5 +1,5 @@ -/* JocStrap - Java/Objective-C Bootstrap - * Copyright (C) 2007 Jay Freeman (saurik) +/* ldid - (Mach-O) Link-Loader Identity Editor + * Copyright (C) 2007-2010 Jay Freeman (saurik) */ /* @@ -36,6 +36,7 @@ */ #include "minimal/stdlib.h" +#include "minimal/string.h" #include "minimal/mapping.h" #include "sha1.h" @@ -51,7 +52,7 @@ struct fat_header { uint32_t magic; uint32_t nfat_arch; -}; +} _packed; #define FAT_MAGIC 0xcafebabe #define FAT_CIGAM 0xbebafeca @@ -62,7 +63,7 @@ struct fat_arch { uint32_t offset; uint32_t size; uint32_t align; -}; +} _packed; struct mach_header { uint32_t magic; @@ -72,45 +73,179 @@ struct mach_header { uint32_t ncmds; uint32_t sizeofcmds; uint32_t flags; -}; +} _packed; #define MH_MAGIC 0xfeedface #define MH_CIGAM 0xcefaedfe -#define MH_EXECUTE 0x2 -#define MH_DYLIB 0x6 -#define MH_BUNDLE 0x8 +#define MH_MAGIC_64 0xfeedfacf +#define MH_CIGAM_64 0xcffaedfe + +#define MH_DYLDLINK 0x4 + +#define MH_EXECUTE 0x2 +#define MH_DYLIB 0x6 +#define MH_BUNDLE 0x8 +#define MH_DYLIB_STUB 0x9 struct load_command { uint32_t cmd; uint32_t cmdsize; -}; - -#define LC_REQ_DYLD 0x80000000 - -#define LC_LOAD_DYLIB 0x0c -#define LC_ID_DYLIB 0x0d -#define LC_UUID 0x1b -#define LC_CODE_SIGNATURE 0x1d -#define LC_REEXPORT_DYLIB (0x1f | LC_REQ_DYLD) +} _packed; + +#define LC_REQ_DYLD uint32_t(0x80000000) + +#define LC_SEGMENT uint32_t(0x01) +#define LC_SYMTAB uint32_t(0x02) +#define LC_DYSYMTAB uint32_t(0x0b) +#define LC_LOAD_DYLIB uint32_t(0x0c) +#define LC_ID_DYLIB uint32_t(0x0d) +#define LC_UUID uint32_t(0x1b) +#define LC_CODE_SIGNATURE uint32_t(0x1d) +#define LC_SEGMENT_SPLIT_INFO uint32_t(0x1e) +#define LC_REEXPORT_DYLIB uint32_t(0x1f | LC_REQ_DYLD) +#define LC_DYLD_INFO uint32_t(0x22) +#define LC_DYLD_INFO_ONLY uint32_t(0x22 | LC_REQ_DYLD) struct dylib { uint32_t name; uint32_t timestamp; uint32_t current_version; uint32_t compatibility_version; -}; +} _packed; struct dylib_command { uint32_t cmd; uint32_t cmdsize; struct dylib dylib; -}; +} _packed; struct uuid_command { uint32_t cmd; uint32_t cmdsize; uint8_t uuid[16]; +} _packed; + +struct symtab_command { + uint32_t cmd; + uint32_t cmdsize; + uint32_t symoff; + uint32_t nsyms; + uint32_t stroff; + uint32_t strsize; +} _packed; + +struct dyld_info_command { + uint32_t cmd; + uint32_t cmdsize; + uint32_t rebase_off; + uint32_t rebase_size; + uint32_t bind_off; + uint32_t bind_size; + uint32_t weak_bind_off; + uint32_t weak_bind_size; + uint32_t lazy_bind_off; + uint32_t lazy_bind_size; + uint32_t export_off; + uint32_t export_size; +} _packed; + +struct dysymtab_command { + uint32_t cmd; + uint32_t cmdsize; + uint32_t ilocalsym; + uint32_t nlocalsym; + uint32_t iextdefsym; + uint32_t nextdefsym; + uint32_t iundefsym; + uint32_t nundefsym; + uint32_t tocoff; + uint32_t ntoc; + uint32_t modtaboff; + uint32_t nmodtab; + uint32_t extrefsymoff; + uint32_t nextrefsyms; + uint32_t indirectsymoff; + uint32_t nindirectsyms; + uint32_t extreloff; + uint32_t nextrel; + uint32_t locreloff; + uint32_t nlocrel; +} _packed; + +struct dylib_table_of_contents { + uint32_t symbol_index; + uint32_t module_index; +} _packed; + +struct dylib_module { + uint32_t module_name; + uint32_t iextdefsym; + uint32_t nextdefsym; + uint32_t irefsym; + uint32_t nrefsym; + uint32_t ilocalsym; + uint32_t nlocalsym; + uint32_t iextrel; + uint32_t nextrel; + uint32_t iinit_iterm; + uint32_t ninit_nterm; + uint32_t objc_module_info_addr; + uint32_t objc_module_info_size; +} _packed; + +struct dylib_reference { + uint32_t isym:24; + uint32_t flags:8; +} _packed; + +struct relocation_info { + int32_t r_address; + uint32_t r_symbolnum:24; + uint32_t r_pcrel:1; + uint32_t r_length:2; + uint32_t r_extern:1; + uint32_t r_type:4; +} _packed; + +struct nlist { + union { + char *n_name; + int32_t n_strx; + } n_un; + + uint8_t n_type; + uint8_t n_sect; + uint8_t n_desc; + uint32_t n_value; +} _packed; + +struct segment_command { + uint32_t cmd; + uint32_t cmdsize; + char segname[16]; + uint32_t vmaddr; + uint32_t vmsize; + uint32_t fileoff; + uint32_t filesize; + uint32_t maxprot; + uint32_t initprot; + uint32_t nsects; + uint32_t flags; +}; + +struct section { + char sectname[16]; + char segname[16]; + uint32_t addr; + uint32_t size; + uint32_t offset; + uint32_t align; + uint32_t reloff; + uint32_t nreloc; + uint32_t flags; + uint32_t reserved1; + uint32_t reserved2; }; struct linkedit_data_command { @@ -118,7 +253,7 @@ struct linkedit_data_command { uint32_t cmdsize; uint32_t dataoff; uint32_t datasize; -}; +} _packed; uint16_t Swap_(uint16_t value) { return @@ -142,12 +277,14 @@ int32_t Swap_(int32_t value) { return Swap_(static_cast(value)); } +bool little_(true); + uint16_t Swap(uint16_t value) { - return true ? Swap_(value) : value; + return little_ ? Swap_(value) : value; } uint32_t Swap(uint32_t value) { - return true ? Swap_(value) : value; + return little_ ? Swap_(value) : value; } int16_t Swap(int16_t value) { @@ -158,14 +295,25 @@ int32_t Swap(int32_t value) { return Swap(static_cast(value)); } -class Framework { +template +class Pointer; + +class Data { private: void *base_; size_t size_; - mach_header *mach_header_; + + protected: bool swapped_; public: + Data(void *base, size_t size) : + base_(base), + size_(size), + swapped_(false) + { + } + uint16_t Swap(uint16_t value) const { return swapped_ ? Swap_(value) : value; } @@ -182,35 +330,51 @@ class Framework { return Swap(static_cast(value)); } - Framework(const char *framework_path) : - swapped_(false) + void *GetBase() const { + return base_; + } + + size_t GetSize() const { + return size_; + } +}; + +class MachHeader : + public Data +{ + private: + bool bits64_; + + struct mach_header *mach_header_; + struct load_command *load_command_; + + public: + MachHeader(void *base, size_t size) : + Data(base, size) { - base_ = map(framework_path, 0, _not(size_t), &size_, false); - fat_header *fat_header = reinterpret_cast(base_); + mach_header_ = (mach_header *) base; - if (Swap(fat_header->magic) == FAT_CIGAM) { - swapped_ = !swapped_; - goto fat; - } else if (Swap(fat_header->magic) != FAT_MAGIC) - mach_header_ = (mach_header *) base_; - else fat: { - size_t fat_narch = Swap(fat_header->nfat_arch); - fat_arch *fat_arch = reinterpret_cast(fat_header + 1); - size_t arch; - for (arch = 0; arch != fat_narch; ++arch) { - uint32_t arch_offset = Swap(fat_arch->offset); - mach_header_ = (mach_header *) ((uint8_t *) base_ + arch_offset); - goto found; - ++fat_arch; - } + switch (Swap(mach_header_->magic)) { + case MH_CIGAM: + swapped_ = !swapped_; + case MH_MAGIC: + bits64_ = false; + break; + + case MH_CIGAM_64: + swapped_ = !swapped_; + case MH_MAGIC_64: + bits64_ = true; + break; - _assert(false); + default: + _assert(false); } - found: - if (Swap(mach_header_->magic) == MH_CIGAM) - swapped_ = !swapped_; - else _assert(Swap(mach_header_->magic) == MH_MAGIC); + void *post = mach_header_ + 1; + if (bits64_) + post = (uint32_t *) post + 1; + load_command_ = (struct load_command *) post; _assert( Swap(mach_header_->filetype) == MH_EXECUTE || @@ -223,18 +387,18 @@ class Framework { return mach_header_; } - void *GetBase() { - return base_; + uint32_t GetCPUType() const { + return Swap(mach_header_->cputype); } - size_t GetSize() { - return size_; + uint16_t GetCPUSubtype() const { + return Swap(mach_header_->cpusubtype) & 0xff; } - std::vector GetLoadCommands() { + std::vector GetLoadCommands() const { std::vector load_commands; - struct load_command *load_command = reinterpret_cast(mach_header_ + 1); + struct load_command *load_command = load_command_; for (uint32_t cmd = 0; cmd != Swap(mach_header_->ncmds); ++cmd) { load_commands.push_back(load_command); load_command = (struct load_command *) ((uint8_t *) load_command + Swap(load_command->cmdsize)); @@ -242,28 +406,179 @@ class Framework { return load_commands; } + + std::vector GetSegments(const char *segment_name) { + std::vector segment_commands; + + _foreach (load_command, GetLoadCommands()) + if (Swap(load_command->cmd) == LC_SEGMENT) { + segment_command *segment_command = reinterpret_cast(load_command); + if (strncmp(segment_command->segname, segment_name, 16) == 0) + segment_commands.push_back(segment_command); + } + + return segment_commands; + } + + std::vector
GetSections(const char *segment_name, const char *section_name) { + std::vector
sections; + + _foreach (segment, GetSegments(segment_name)) { + section *section = (struct section *) (segment + 1); + + uint32_t sect; + for (sect = 0; sect != Swap(segment->nsects); ++sect) { + if (strncmp(section->sectname, section_name, 16) == 0) + sections.push_back(section); + ++section; + } + } + + return sections; + } + + template + Pointer GetPointer(uint32_t address, const char *segment_name = NULL) const { + load_command *load_command = (struct load_command *) (mach_header_ + 1); + uint32_t cmd; + + for (cmd = 0; cmd != Swap(mach_header_->ncmds); ++cmd) { + if (Swap(load_command->cmd) == LC_SEGMENT) { + segment_command *segment_command = (struct segment_command *) load_command; + if (segment_name != NULL && strncmp(segment_command->segname, segment_name, 16) != 0) + goto next_command; + + section *sections = (struct section *) (segment_command + 1); + + uint32_t sect; + for (sect = 0; sect != Swap(segment_command->nsects); ++sect) { + section *section = §ions[sect]; + //printf("%s %u %p %p %u\n", segment_command->segname, sect, address, section->addr, section->size); + if (address >= Swap(section->addr) && address < Swap(section->addr) + Swap(section->size)) { + //printf("0x%.8x %s\n", address, segment_command->segname); + return Pointer(this, reinterpret_cast(address - Swap(section->addr) + Swap(section->offset) + (char *) mach_header_)); + } + } + } + + next_command: + load_command = (struct load_command *) ((char *) load_command + Swap(load_command->cmdsize)); + } + + return Pointer(this); + } + + template + Pointer GetOffset(uint32_t offset) { + return Pointer(this, reinterpret_cast(offset + (uint8_t *) mach_header_)); + } +}; + +class FatHeader : + public Data +{ + private: + fat_header *fat_header_; + std::vector mach_headers_; + + public: + FatHeader(void *base, size_t size) : + Data(base, size) + { + fat_header_ = reinterpret_cast(base); + + if (Swap(fat_header_->magic) == FAT_CIGAM) { + swapped_ = !swapped_; + goto fat; + } else if (Swap(fat_header_->magic) != FAT_MAGIC) { + fat_header_ = NULL; + mach_headers_.push_back(MachHeader(base, size)); + } else fat: { + size_t fat_narch = Swap(fat_header_->nfat_arch); + fat_arch *fat_arch = reinterpret_cast(fat_header_ + 1); + size_t arch; + for (arch = 0; arch != fat_narch; ++arch) { + uint32_t arch_offset = Swap(fat_arch->offset); + uint32_t arch_size = Swap(fat_arch->size); + mach_headers_.push_back(MachHeader((uint8_t *) base + arch_offset, size)); + ++fat_arch; + } + } + } + + std::vector &GetMachHeaders() { + return mach_headers_; + } + + bool IsFat() const { + return fat_header_ != NULL; + } +}; + +FatHeader Map(const char *path) { + size_t size; + void *base(map(path, 0, _not(size_t), &size, false)); + return FatHeader(base, size); +} + +template +class Pointer { + private: + const MachHeader *framework_; + const Target_ *pointer_; + + public: + Pointer(const MachHeader *framework = NULL, const Target_ *pointer = NULL) : + framework_(framework), + pointer_(pointer) + { + } + + operator const Target_ *() const { + return pointer_; + } + + const Target_ *operator ->() const { + return pointer_; + } + + Pointer &operator ++() { + ++pointer_; + return *this; + } + + template + Value_ Swap(Value_ value) { + return framework_->Swap(value); + } }; -#define CSMAGIC_CODEDIRECTORY 0xfade0c02 -#define CSMAGIC_EMBEDDED_SIGNATURE 0xfade0cc0 -#define CSSLOT_CODEDIRECTORY 0 -#define CSSLOT_REQUIREMENTS 2 +#define CSMAGIC_CODEDIRECTORY uint32_t(0xfade0c02) +#define CSMAGIC_EMBEDDED_SIGNATURE uint32_t(0xfade0cc0) +#define CSMAGIC_ENTITLEMENTS uint32_t(0xfade7171) + +#define CSSLOT_CODEDIRECTORY uint32_t(0) +#define CSSLOT_REQUIREMENTS uint32_t(2) +#define CSSLOT_ENTITLEMENTS uint32_t(5) struct BlobIndex { uint32_t type; uint32_t offset; -}; +} _packed; -struct SuperBlob { +struct Blob { uint32_t magic; uint32_t length; +} _packed; + +struct SuperBlob { + struct Blob blob; uint32_t count; struct BlobIndex index[]; -}; +} _packed; struct CodeDirectory { - uint32_t magic; - uint32_t length; + struct Blob blob; uint32_t version; uint32_t flags; uint32_t hashOffset; @@ -276,12 +591,10 @@ struct CodeDirectory { uint8_t spare1; uint8_t pageSize; uint32_t spare2; -}; +} _packed; extern "C" uint32_t hash(uint8_t *k, uint32_t length, uint32_t initval); -#define CODESIGN_ALLOCATE "arm-apple-darwin9-codesign_allocate" - void sha1(uint8_t *hash, uint8_t *data, size_t size) { SHA1Context context; SHA1Reset(&context); @@ -289,30 +602,84 @@ void sha1(uint8_t *hash, uint8_t *data, size_t size) { SHA1Result(&context, hash); } +struct CodesignAllocation { + uint32_t type_; + uint16_t subtype_; + size_t size_; + + CodesignAllocation(uint32_t type, uint16_t subtype, size_t size) : + type_(type), + subtype_(subtype), + size_(size) + { + } +}; + int main(int argc, const char *argv[]) { + union { + uint16_t word; + uint8_t byte[2]; + } endian = {1}; + + little_ = endian.byte[0]; + bool flag_R(false); + bool flag_r(false); + bool flag_t(false); bool flag_p(false); bool flag_u(false); + bool flag_e(false); bool flag_T(false); + bool flag_S(false); + bool flag_s(false); bool timeh(false); uint32_t timev(0); + const void *xmld(NULL); + size_t xmls(0); + + uintptr_t noffset(_not(uintptr_t)); + uintptr_t woffset(_not(uintptr_t)); + std::vector files; - _assert(argc != 0); + if (argc == 1) { + fprintf(stderr, "usage: %s -S[entitlements.xml] \n", argv[0]); + fprintf(stderr, " %s -e MobileSafari\n", argv[0]); + fprintf(stderr, " %s -S cat\n", argv[0]); + fprintf(stderr, " %s -Stfp.xml gdb\n", argv[0]); + exit(0); + } + for (int argi(1); argi != argc; ++argi) if (argv[argi][0] != '-') files.push_back(argv[argi]); else switch (argv[argi][1]) { case 'R': flag_R = true; break; + case 'r': flag_r = true; break; + case 't': flag_t = true; break; case 'u': flag_u = true; break; case 'p': flag_p = true; break; - case 'S': flag_S = true; break; + case 'e': flag_e = true; break; + + case 's': + _assert(!flag_S); + flag_s = true; + break; + + case 'S': + _assert(!flag_s); + flag_S = true; + if (argv[argi][2] != '\0') { + const char *xml = argv[argi] + 2; + xmld = map(xml, 0, _not(size_t), &xmls, true); + } + break; case 'T': { flag_T = true; @@ -325,6 +692,18 @@ int main(int argc, const char *argv[]) { } } break; + case 'n': { + char *arge; + noffset = strtoul(argv[argi] + 2, &arge, 0); + _assert(arge == argv[argi] + strlen(argv[argi])); + } break; + + case 'w': { + char *arge; + woffset = strtoul(argv[argi] + 2, &arge, 0); + _assert(arge == argv[argi] + strlen(argv[argi])); + } break; + default: goto usage; break; @@ -336,59 +715,152 @@ int main(int argc, const char *argv[]) { size_t filei(0), filee(0); _foreach (file, files) try { - const char *path(file->c_str()); + const char *path(file.c_str()); const char *base = strrchr(path, '/'); char *temp(NULL), *dir; - mode_t mode = 0; if (base != NULL) - dir = strndup(path, base++ - path + 1); + dir = strndup_(path, base++ - path + 1); else { dir = strdup(""); base = path; } + if (flag_r) { + size_t clip(_not(size_t)); { + FatHeader fat_header(Map(path)); + _foreach (mach_header, fat_header.GetMachHeaders()) { + mach_header->flags = mach_header.Swap(mach_header.Swap(mach_header->flags) | MH_DYLDLINK); + + size_t size(_not(size_t)); { + _foreach (load_command, mach_header.GetLoadCommands()) { + switch (mach_header.Swap(load_command->cmd)) { + case LC_CODE_SIGNATURE: { + struct linkedit_data_command *signature = reinterpret_cast(load_command); + memset(signature, 0, sizeof(struct linkedit_data_command)); + + mach_header->ncmds -= 1; + mach_header->sizeofcmds -= sizeof(struct linkedit_data_command); + } break; + + case LC_SYMTAB: { + struct symtab_command *symtab = reinterpret_cast(load_command); + size = symtab->stroff + symtab->strsize; + } break; + } + } + + _foreach (segment, const_cast(mach_header).GetSegments("__LINKEDIT")) { + segment->filesize -= mach_header.GetSize() - size; + + if (!fat_header.IsFat()) + clip = size; + else + _assert(false); + } + } + } + } + + if (clip != _not(size_t)) + _syscall(truncate(path, clip)); + } + if (flag_S) { asprintf(&temp, "%s.%s.cs", dir, base); const char *allocate = getenv("CODESIGN_ALLOCATE"); if (allocate == NULL) allocate = "codesign_allocate"; - size_t size = _not(size_t); - const char *arch; { - Framework framework(path); - _foreach (load_command, framework.GetLoadCommands()) { - uint32_t cmd(framework.Swap((*load_command)->cmd)); - if (cmd == LC_CODE_SIGNATURE) { - struct linkedit_data_command *signature = reinterpret_cast(*load_command); - size = framework.Swap(signature->dataoff); - _assert(size < framework.GetSize()); - break; + std::vector allocations; { + FatHeader fat_header(Map(path)); + _foreach (mach_header, fat_header.GetMachHeaders()) { + mach_header->flags = mach_header.Swap(mach_header.Swap(mach_header->flags) | MH_DYLDLINK); + + size_t size(_not(size_t)); { + _foreach (load_command, mach_header.GetLoadCommands()) { + uint32_t cmd(mach_header.Swap(load_command->cmd)); + if (cmd == LC_CODE_SIGNATURE) { + struct linkedit_data_command *signature = reinterpret_cast(load_command); + size = mach_header.Swap(signature->dataoff); + _assert(size < mach_header.GetSize()); + break; + } + } + + if (size == _not(size_t)) + size = mach_header.GetSize(); } - } - if (size == _not(size_t)) - size = framework.GetSize(); - - switch (framework->cputype) { - case 12: switch (framework->cpusubtype) { - case 0: arch = "arm"; break; - case 6: arch = "armv6"; break; - default: arch = NULL; break; - } break; - - default: arch = NULL; break; + allocations.push_back(CodesignAllocation(mach_header.GetCPUType(), mach_header.GetCPUSubtype(), size)); } } - _assert(arch != NULL); - pid_t pid = fork(); _syscall(pid); if (pid == 0) { - char *ssize; - asprintf(&ssize, "%u", (sizeof(struct SuperBlob) + 2 * sizeof(struct BlobIndex) + sizeof(struct CodeDirectory) + strlen(base) + 1 + (size + 0x1000 - 1) / 0x1000 * 0x14 + 0xc + 15) / 16 * 16); - execlp(allocate, allocate, "-i", path, "-a", arch, ssize, "-o", temp, NULL); + // XXX: this leaks memory, but it doesn't really matter + std::vector args; + char *arg; + + args.push_back(allocate); + + args.push_back("-i"); + args.push_back(path); + + _foreach (allocation, allocations) { + args.push_back("-A"); + + asprintf(&arg, "%u", allocation.type_); + args.push_back(arg); + + asprintf(&arg, "%u", allocation.subtype_); + args.push_back(arg); + + size_t alloc(0); + alloc += sizeof(struct SuperBlob); + uint32_t special(0); + + special = std::max(special, CSSLOT_CODEDIRECTORY); + alloc += sizeof(struct BlobIndex); + alloc += sizeof(struct CodeDirectory); + alloc += strlen(base) + 1; + + special = std::max(special, CSSLOT_REQUIREMENTS); + alloc += sizeof(struct BlobIndex); + alloc += 0xc; + + if (xmld != NULL) { + special = std::max(special, CSSLOT_ENTITLEMENTS); + alloc += sizeof(struct BlobIndex); + alloc += sizeof(struct Blob); + alloc += xmls; + } + + size_t normal((allocation.size_ + 0x1000 - 1) / 0x1000); + alloc += (special + normal) * 0x14; + + alloc += 15; + alloc /= 16; + alloc *= 16; + + asprintf(&arg, "%u", alloc); + args.push_back(arg); + } + + args.push_back("-o"); + args.push_back(temp); + + args.push_back(NULL); + + if (false) { + printf("run:"); + _foreach (arg, args) + printf(" %s", arg); + printf("\n"); + } + + execvp(allocate, (char **) &args[0]); _assert(false); } @@ -398,117 +870,223 @@ int main(int argc, const char *argv[]) { _assert(WEXITSTATUS(status) == 0); } - Framework framework(temp == NULL ? path : temp); + if (flag_p) + printf("path%zu='%s'\n", filei, file.c_str()); + + FatHeader fat_header(Map(temp == NULL ? path : temp)); struct linkedit_data_command *signature(NULL); - if (flag_p) - printf("path%zu='%s'\n", filei, file->c_str()); - - _foreach (load_command, framework.GetLoadCommands()) { - uint32_t cmd(framework.Swap((*load_command)->cmd)); - - if (flag_R && cmd == LC_REEXPORT_DYLIB) - (*load_command)->cmd = framework.Swap(LC_LOAD_DYLIB); - else if (cmd == LC_CODE_SIGNATURE) - signature = reinterpret_cast(*load_command); - else if (cmd == LC_UUID) { - volatile struct uuid_command *uuid_command(reinterpret_cast(*load_command)); - - if (flag_u) { - printf("uuid%zu=%.2x%.2x%.2x%.2x-%.2x%.2x-%.2x%.2x-%.2x%.2x-%.2x%.2x%.2x%.2x%.2x%.2x\n", filei, - uuid_command->uuid[ 0], uuid_command->uuid[ 1], uuid_command->uuid[ 2], uuid_command->uuid[ 3], - uuid_command->uuid[ 4], uuid_command->uuid[ 5], uuid_command->uuid[ 6], uuid_command->uuid[ 7], - uuid_command->uuid[ 8], uuid_command->uuid[ 9], uuid_command->uuid[10], uuid_command->uuid[11], - uuid_command->uuid[12], uuid_command->uuid[13], uuid_command->uuid[14], uuid_command->uuid[15] - ); + _foreach (mach_header, fat_header.GetMachHeaders()) { + if (woffset != _not(uintptr_t)) { + Pointer wvalue(mach_header.GetPointer(woffset)); + if (wvalue == NULL) + printf("(null) %p\n", reinterpret_cast(woffset)); + else + printf("0x%.08x\n", *wvalue); + } + + if (noffset != _not(uintptr_t)) + printf("%s\n", &*mach_header.GetPointer(noffset)); + + _foreach (load_command, mach_header.GetLoadCommands()) { + uint32_t cmd(mach_header.Swap(load_command->cmd)); + + if (flag_R && cmd == LC_REEXPORT_DYLIB) + load_command->cmd = mach_header.Swap(LC_LOAD_DYLIB); + else if (cmd == LC_CODE_SIGNATURE) + signature = reinterpret_cast(load_command); + else if (cmd == LC_UUID) { + volatile struct uuid_command *uuid_command(reinterpret_cast(load_command)); + + if (flag_u) { + printf("uuid%zu=%.2x%.2x%.2x%.2x-%.2x%.2x-%.2x%.2x-%.2x%.2x-%.2x%.2x%.2x%.2x%.2x%.2x\n", filei, + uuid_command->uuid[ 0], uuid_command->uuid[ 1], uuid_command->uuid[ 2], uuid_command->uuid[ 3], + uuid_command->uuid[ 4], uuid_command->uuid[ 5], uuid_command->uuid[ 6], uuid_command->uuid[ 7], + uuid_command->uuid[ 8], uuid_command->uuid[ 9], uuid_command->uuid[10], uuid_command->uuid[11], + uuid_command->uuid[12], uuid_command->uuid[13], uuid_command->uuid[14], uuid_command->uuid[15] + ); + } + } else if (cmd == LC_ID_DYLIB) { + volatile struct dylib_command *dylib_command(reinterpret_cast(load_command)); + + if (flag_t) + printf("time%zu=0x%.8x\n", filei, mach_header.Swap(dylib_command->dylib.timestamp)); + + if (flag_T) { + uint32_t timed; + + if (!timeh) + timed = timev; + else { + dylib_command->dylib.timestamp = 0; + timed = hash(reinterpret_cast(mach_header.GetBase()), mach_header.GetSize(), timev); + } + + dylib_command->dylib.timestamp = mach_header.Swap(timed); + } } - } else if (cmd == LC_ID_DYLIB) { - volatile struct dylib_command *dylib_command(reinterpret_cast(*load_command)); + } + + if (flag_e) { + _assert(signature != NULL); - if (flag_t) - printf("time%zu=0x%.8x\n", filei, framework.Swap(dylib_command->dylib.timestamp)); + uint32_t data = mach_header.Swap(signature->dataoff); + uint32_t size = mach_header.Swap(signature->datasize); - if (flag_T) { - uint32_t timed; + uint8_t *top = reinterpret_cast(mach_header.GetBase()); + uint8_t *blob = top + data; + struct SuperBlob *super = reinterpret_cast(blob); - if (!timeh) - timed = timev; - else { - dylib_command->dylib.timestamp = 0; - timed = hash(reinterpret_cast(framework.GetBase()), framework.GetSize(), timev); + for (size_t index(0); index != Swap(super->count); ++index) + if (Swap(super->index[index].type) == CSSLOT_ENTITLEMENTS) { + uint32_t begin = Swap(super->index[index].offset); + struct Blob *entitlements = reinterpret_cast(blob + begin); + fwrite(entitlements + 1, 1, Swap(entitlements->length) - sizeof(struct Blob), stdout); } + } - dylib_command->dylib.timestamp = framework.Swap(timed); - } + if (flag_s) { + _assert(signature != NULL); + + uint32_t data = mach_header.Swap(signature->dataoff); + uint32_t size = mach_header.Swap(signature->datasize); + + uint8_t *top = reinterpret_cast(mach_header.GetBase()); + uint8_t *blob = top + data; + struct SuperBlob *super = reinterpret_cast(blob); + + for (size_t index(0); index != Swap(super->count); ++index) + if (Swap(super->index[index].type) == CSSLOT_CODEDIRECTORY) { + uint32_t begin = Swap(super->index[index].offset); + struct CodeDirectory *directory = reinterpret_cast(blob + begin); + + uint8_t (*hashes)[20] = reinterpret_cast(blob + begin + Swap(directory->hashOffset)); + uint32_t pages = Swap(directory->nCodeSlots); + + if (pages != 1) + for (size_t i = 0; i != pages - 1; ++i) + sha1(hashes[i], top + 0x1000 * i, 0x1000); + if (pages != 0) + sha1(hashes[pages - 1], top + 0x1000 * (pages - 1), ((data - 1) % 0x1000) + 1); + } } - } - if (flag_S) { - _assert(signature != NULL); + if (flag_S) { + _assert(signature != NULL); + + uint32_t data = mach_header.Swap(signature->dataoff); + uint32_t size = mach_header.Swap(signature->datasize); + + uint8_t *top = reinterpret_cast(mach_header.GetBase()); + uint8_t *blob = top + data; + struct SuperBlob *super = reinterpret_cast(blob); + super->blob.magic = Swap(CSMAGIC_EMBEDDED_SIGNATURE); + + uint32_t count = xmld == NULL ? 2 : 3; + uint32_t offset = sizeof(struct SuperBlob) + count * sizeof(struct BlobIndex); + + super->index[0].type = Swap(CSSLOT_CODEDIRECTORY); + super->index[0].offset = Swap(offset); - uint32_t data = framework.Swap(signature->dataoff); - uint32_t size = framework.Swap(signature->datasize); + uint32_t begin = offset; + struct CodeDirectory *directory = reinterpret_cast(blob + begin); + offset += sizeof(struct CodeDirectory); - uint8_t *top = reinterpret_cast(framework.GetBase()); - uint8_t *blob = top + data; - struct SuperBlob *super = reinterpret_cast(blob); - super->magic = Swap(CSMAGIC_EMBEDDED_SIGNATURE); + directory->blob.magic = Swap(CSMAGIC_CODEDIRECTORY); + directory->version = Swap(uint32_t(0x00020001)); + directory->flags = Swap(uint32_t(0)); + directory->codeLimit = Swap(data); + directory->hashSize = 0x14; + directory->hashType = 0x01; + directory->spare1 = 0x00; + directory->pageSize = 0x0c; + directory->spare2 = Swap(uint32_t(0)); - uint32_t count = 2; - uint32_t offset = sizeof(struct SuperBlob) + count * sizeof(struct BlobIndex); + directory->identOffset = Swap(offset - begin); + strcpy(reinterpret_cast(blob + offset), base); + offset += strlen(base) + 1; - super->index[0].type = Swap(CSSLOT_CODEDIRECTORY); - super->index[0].offset = Swap(offset); + uint32_t special = xmld == NULL ? CSSLOT_REQUIREMENTS : CSSLOT_ENTITLEMENTS; + directory->nSpecialSlots = Swap(special); - uint32_t begin = offset; - struct CodeDirectory *directory = reinterpret_cast(blob + begin); - offset += sizeof(struct CodeDirectory); + uint8_t (*hashes)[20] = reinterpret_cast(blob + offset); + memset(hashes, 0, sizeof(*hashes) * special); - directory->magic = Swap(CSMAGIC_CODEDIRECTORY); - directory->version = Swap(0x00020001); - directory->flags = Swap(0); - directory->codeLimit = Swap(data); - directory->hashSize = 0x14; - directory->hashType = 0x01; - directory->spare1 = 0x00; - directory->pageSize = 0x0c; - directory->spare2 = Swap(0); + offset += sizeof(*hashes) * special; + hashes += special; - directory->identOffset = Swap(offset - begin); - strcpy(reinterpret_cast(blob + offset), base); - offset += strlen(base) + 1; + uint32_t pages = (data + 0x1000 - 1) / 0x1000; + directory->nCodeSlots = Swap(pages); - uint8_t (*hashes)[20] = reinterpret_cast(blob + offset); - uint32_t special = 0; + if (pages != 1) + for (size_t i = 0; i != pages - 1; ++i) + sha1(hashes[i], top + 0x1000 * i, 0x1000); + if (pages != 0) + sha1(hashes[pages - 1], top + 0x1000 * (pages - 1), ((data - 1) % 0x1000) + 1); - uint32_t pages = (data + 0x1000 - 1) / 0x1000; - directory->nSpecialSlots = Swap(special); - directory->nCodeSlots = Swap(pages); + directory->hashOffset = Swap(offset - begin); + offset += sizeof(*hashes) * pages; + directory->blob.length = Swap(offset - begin); - if (pages != 1) - for (size_t i = 0; i != pages - 1; ++i) - sha1(hashes[special + i], top + 0x1000 * i, 0x1000); - if (pages != 0) - sha1(hashes[special + pages - 1], top + 0x1000 * (pages - 1), data % 0x1000); + super->index[1].type = Swap(CSSLOT_REQUIREMENTS); + super->index[1].offset = Swap(offset); - directory->hashOffset = Swap(offset - begin); - offset += sizeof(*hashes) * (special + pages); - directory->length = Swap(offset - begin); + memcpy(blob + offset, "\xfa\xde\x0c\x01\x00\x00\x00\x0c\x00\x00\x00\x00", 0xc); + offset += 0xc; - super->index[1].type = Swap(CSSLOT_REQUIREMENTS); - super->index[1].offset = Swap(offset); + if (xmld != NULL) { + super->index[2].type = Swap(CSSLOT_ENTITLEMENTS); + super->index[2].offset = Swap(offset); - memcpy(blob + offset, "\xfa\xde\x0c\x01\x00\x00\x00\x0c\x00\x00\x00\x00", 0xc); - offset += 0xc; + uint32_t begin = offset; + struct Blob *entitlements = reinterpret_cast(blob + begin); + offset += sizeof(struct Blob); - super->count = Swap(count); - super->length = Swap(offset); + memcpy(blob + offset, xmld, xmls); + offset += xmls; - _assert(offset <= size); - memset(blob + offset, 0, size - offset); + entitlements->magic = Swap(CSMAGIC_ENTITLEMENTS); + entitlements->length = Swap(offset - begin); + } + + for (size_t index(0); index != count; ++index) { + uint32_t type = Swap(super->index[index].type); + if (type != 0 && type <= special) { + uint32_t offset = Swap(super->index[index].offset); + struct Blob *local = (struct Blob *) (blob + offset); + sha1((uint8_t *) (hashes - type), (uint8_t *) local, Swap(local->length)); + } + } + + super->count = Swap(count); + super->blob.length = Swap(offset); + + if (offset > size) { + fprintf(stderr, "offset (%u) > size (%u)\n", offset, size); + _assert(false); + } //else fprintf(stderr, "offset (%zu) <= size (%zu)\n", offset, size); + + memset(blob + offset, 0, size - offset); + } + } + + if (flag_S) { + uint8_t *top = reinterpret_cast(fat_header.GetBase()); + size_t size = fat_header.GetSize(); + + char *copy; + asprintf(©, "%s.%s.cp", dir, base); + FILE *file = fopen(copy, "w+"); + size_t writ = fwrite(top, 1, size, file); + _assert(writ == size); + fclose(file); + + _syscall(unlink(temp)); + free(temp); + temp = copy; } - if (temp) { + if (temp != NULL) { struct stat info; _syscall(stat(path, &info)); _syscall(chown(temp, info.st_uid, info.st_gid));