X-Git-Url: https://git.saurik.com/ldid.git/blobdiff_plain/289ccbbc21b8bd076510cbc08392087389b59dea..dede61211e9c6d4384a0eda92c9680f19292ef23:/ldid.cpp diff --git a/ldid.cpp b/ldid.cpp index c246539..7dec246 100644 --- a/ldid.cpp +++ b/ldid.cpp @@ -1,54 +1,40 @@ /* ldid - (Mach-O) Link-Loader Identity Editor - * Copyright (C) 2007-2010 Jay Freeman (saurik) + * Copyright (C) 2007-2012 Jay Freeman (saurik) */ +/* GNU Affero General Public License, Version 3 {{{ */ /* - * Redistribution and use in source and binary - * forms, with or without modification, are permitted - * provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the - * above copyright notice, this list of conditions - * and the following disclaimer. - * 2. Redistributions in binary form must reproduce the - * above copyright notice, this list of conditions - * and the following disclaimer in the documentation - * and/or other materials provided with the - * distribution. - * 3. The name of the author may not be used to endorse - * or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, - * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR - * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. -#include "minimal/stdlib.h" -#include "minimal/string.h" -#include "minimal/mapping.h" + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. -#include "sha1.h" + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . +**/ +/* }}} */ + +#include "minimal/stdlib.h" #include #include #include -#include -#include +#include +#include + +#include #include +#include + +#include + struct fat_header { uint32_t magic; uint32_t nfat_arch; @@ -83,6 +69,7 @@ struct mach_header { #define MH_DYLDLINK 0x4 +#define MH_OBJECT 0x1 #define MH_EXECUTE 0x2 #define MH_DYLIB 0x6 #define MH_BUNDLE 0x8 @@ -105,6 +92,7 @@ struct load_command { #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_ENCRYPTION_INFO uint32_t(0x21) #define LC_DYLD_INFO uint32_t(0x22) #define LC_DYLD_INFO_ONLY uint32_t(0x22 | LC_REQ_DYLD) @@ -233,7 +221,7 @@ struct segment_command { uint32_t initprot; uint32_t nsects; uint32_t flags; -}; +} _packed; struct segment_command_64 { uint32_t cmd; @@ -247,7 +235,7 @@ struct segment_command_64 { uint32_t initprot; uint32_t nsects; uint32_t flags; -}; +} _packed; struct section { char sectname[16]; @@ -261,7 +249,7 @@ struct section { uint32_t flags; uint32_t reserved1; uint32_t reserved2; -}; +} _packed; struct section_64 { char sectname[16]; @@ -275,7 +263,7 @@ struct section_64 { uint32_t flags; uint32_t reserved1; uint32_t reserved2; -}; +} _packed; struct linkedit_data_command { uint32_t cmd; @@ -284,6 +272,38 @@ struct linkedit_data_command { uint32_t datasize; } _packed; +struct encryption_info_command { + uint32_t cmd; + uint32_t cmdsize; + uint32_t cryptoff; + uint32_t cryptsize; + uint32_t cryptid; +} _packed; + +#define BIND_OPCODE_MASK 0xf0 +#define BIND_IMMEDIATE_MASK 0x0f +#define BIND_OPCODE_DONE 0x00 +#define BIND_OPCODE_SET_DYLIB_ORDINAL_IMM 0x10 +#define BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB 0x20 +#define BIND_OPCODE_SET_DYLIB_SPECIAL_IMM 0x30 +#define BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM 0x40 +#define BIND_OPCODE_SET_TYPE_IMM 0x50 +#define BIND_OPCODE_SET_ADDEND_SLEB 0x60 +#define BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB 0x70 +#define BIND_OPCODE_ADD_ADDR_ULEB 0x80 +#define BIND_OPCODE_DO_BIND 0x90 +#define BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB 0xa0 +#define BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED 0xb0 +#define BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB 0xc0 + +template +Type_ Align(Type_ value, size_t align) { + value += align - 1; + value /= align; + value *= align; + return value; +} + uint16_t Swap_(uint16_t value) { return ((value >> 8) & 0x00ff) | @@ -298,6 +318,13 @@ uint32_t Swap_(uint32_t value) { return value; } +uint64_t Swap_(uint64_t value) { + value = (value & 0x00000000ffffffff) << 32 | (value & 0xffffffff00000000) >> 32; + value = (value & 0x0000ffff0000ffff) << 16 | (value & 0xffff0000ffff0000) >> 16; + value = (value & 0x00ff00ff00ff00ff) << 8 | (value & 0xff00ff00ff00ff00) >> 8; + return value; +} + int16_t Swap_(int16_t value) { return Swap_(static_cast(value)); } @@ -306,6 +333,10 @@ int32_t Swap_(int32_t value) { return Swap_(static_cast(value)); } +int64_t Swap_(int64_t value) { + return Swap_(static_cast(value)); +} + bool little_(true); uint16_t Swap(uint16_t value) { @@ -316,6 +347,10 @@ uint32_t Swap(uint32_t value) { return little_ ? Swap_(value) : value; } +uint64_t Swap(uint64_t value) { + return little_ ? Swap_(value) : value; +} + int16_t Swap(int16_t value) { return Swap(static_cast(value)); } @@ -324,6 +359,10 @@ int32_t Swap(int32_t value) { return Swap(static_cast(value)); } +int64_t Swap(int64_t value) { + return Swap(static_cast(value)); +} + template class Pointer; @@ -351,6 +390,10 @@ class Data { return swapped_ ? Swap_(value) : value; } + uint64_t Swap(uint64_t value) const { + return swapped_ ? Swap_(value) : value; + } + int16_t Swap(int16_t value) const { return Swap(static_cast(value)); } @@ -359,6 +402,10 @@ class Data { return Swap(static_cast(value)); } + int64_t Swap(int64_t value) const { + return Swap(static_cast(value)); + } + void *GetBase() const { return base_; } @@ -416,14 +463,22 @@ class MachHeader : return mach_header_; } + operator struct mach_header *() const { + return mach_header_; + } + uint32_t GetCPUType() const { return Swap(mach_header_->cputype); } - uint16_t GetCPUSubtype() const { + uint32_t GetCPUSubtype() const { return Swap(mach_header_->cpusubtype) & 0xff; } + struct load_command *GetLoadCommand() const { + return load_command_; + } + std::vector GetLoadCommands() const { std::vector load_commands; @@ -436,7 +491,7 @@ class MachHeader : return load_commands; } - std::vector GetSegments(const char *segment_name) { + std::vector GetSegments(const char *segment_name) const { std::vector segment_commands; _foreach (load_command, GetLoadCommands()) { @@ -450,7 +505,7 @@ class MachHeader : return segment_commands; } - std::vector GetSegments64(const char *segment_name) { + std::vector GetSegments64(const char *segment_name) const { std::vector segment_commands; _foreach (load_command, GetLoadCommands()) { @@ -464,7 +519,7 @@ class MachHeader : return segment_commands; } - std::vector
GetSections(const char *segment_name, const char *section_name) { + std::vector
GetSections(const char *segment_name, const char *section_name) const { std::vector
sections; _foreach (segment, GetSegments(segment_name)) { @@ -579,13 +634,11 @@ class FatHeader : struct fat_header *operator ->() const { return fat_header_; } -}; -FatHeader Map(const char *path, bool ro = false) { - size_t size; - void *base(map(path, 0, _not(size_t), &size, ro)); - return FatHeader(base, size); -} + operator struct fat_header *() const { + return fat_header_; + } +}; template class Pointer { @@ -662,23 +715,100 @@ struct CodeDirectory { extern "C" uint32_t hash(uint8_t *k, uint32_t length, uint32_t initval); void sha1(uint8_t *hash, uint8_t *data, size_t size) { - SHA1Context context; - SHA1Reset(&context); - SHA1Input(&context, data, size); - SHA1Result(&context, hash); + SHA1(data, size, hash); } struct CodesignAllocation { - uint32_t type_; - uint16_t subtype_; + FatMachHeader mach_header_; + uint32_t offset_; + uint32_t size_; + uint32_t alloc_; + uint32_t align_; + + CodesignAllocation(FatMachHeader mach_header, size_t offset, size_t size, size_t alloc, size_t align) : + mach_header_(mach_header), + offset_(offset), + size_(size), + alloc_(alloc), + align_(align) + { + } +}; + +class File { + private: + int file_; + + public: + File() : + file_(-1) + { + } + + ~File() { + if (file_ != -1) + _syscall(close(file_)); + } + + void open(const char *path, bool ro) { + _assert(file_ == -1); + _syscall(file_ = ::open(path, ro ? O_RDONLY : O_RDWR)); + } + + int file() const { + return file_; + } +}; + +class Map { + private: + File file_; + void *data_; size_t size_; - CodesignAllocation(uint32_t type, uint16_t subtype, size_t size) : - type_(type), - subtype_(subtype), - size_(size) + void clear() { + if (data_ == NULL) + return; + _syscall(munmap(data_, size_)); + data_ = NULL; + size_ = 0; + } + + public: + Map() : + data_(NULL), + size_(0) { } + + Map(const char *path, bool ro) { + open(path, ro); + } + + ~Map() { + clear(); + } + + void open(const char *path, bool ro) { + clear(); + + file_.open(path, ro); + int file(file_.file()); + + struct stat stat; + _syscall(fstat(file, &stat)); + size_ = stat.st_size; + + _syscall(data_ = mmap(NULL, size_, ro ? PROT_READ : PROT_READ | PROT_WRITE, ro ? MAP_PRIVATE : MAP_SHARED, file, 0)); + } + + void *data() const { + return data_; + } + + size_t size() const { + return size_; + } }; int main(int argc, const char *argv[]) { @@ -702,9 +832,23 @@ int main(int argc, const char *argv[]) { bool flag_S(false); bool flag_s(false); + bool flag_O(false); + + bool flag_D(false); + bool flag_d(false); + + bool flag_A(false); + bool flag_a(false); + + uint32_t flag_CPUType(_not(uint32_t)); + uint32_t flag_CPUSubtype(_not(uint32_t)); + + const char *flag_I(NULL); + bool timeh(false); uint32_t timev(0); + Map xmlm; const void *xmld(NULL); size_t xmls(0); @@ -732,6 +876,26 @@ int main(int argc, const char *argv[]) { case 'u': flag_u = true; break; case 'p': flag_p = true; break; case 'e': flag_e = true; break; + case 'O': flag_O = true; break; + + case 'D': flag_D = true; break; + case 'd': flag_d = true; break; + + case 'a': flag_a = true; break; + + case 'A': + flag_A = true; + if (argv[argi][2] != '\0') { + const char *cpu = argv[argi] + 2; + const char *colon = strchr(cpu, ':'); + _assert(colon != NULL); + char *arge; + flag_CPUType = strtoul(cpu, &arge, 0); + _assert(arge == colon); + flag_CPUSubtype = strtoul(colon + 1, &arge, 0); + _assert(arge == argv[argi] + strlen(argv[argi])); + } + break; case 's': _assert(!flag_S); @@ -743,7 +907,9 @@ int main(int argc, const char *argv[]) { flag_S = true; if (argv[argi][2] != '\0') { const char *xml = argv[argi] + 2; - xmld = map(xml, 0, _not(size_t), &xmls, true); + xmlm.open(xml, true); + xmld = xmlm.data(); + xmls = xmlm.size(); } break; @@ -758,6 +924,10 @@ int main(int argc, const char *argv[]) { } } break; + case 'I': { + flag_I = argv[argi] + 2; + } break; + case 'n': { char *arge; noffset = strtoul(argv[argi] + 2, &arge, 0); @@ -783,19 +953,28 @@ int main(int argc, const char *argv[]) { _foreach (file, files) try { const char *path(file.c_str()); const char *base = strrchr(path, '/'); - char *temp(NULL), *dir; + std::string dir; if (base != NULL) - dir = strndup_(path, base++ - path + 1); - else { - dir = strdup(""); + dir.assign(path, base++ - path + 1); + else base = path; - } + + const char *name(flag_I ?: base); + char *temp(NULL); if (flag_r) { uint32_t clip(0); { - FatHeader fat_header(Map(path)); + Map mapping(path, false); + FatHeader fat_header(mapping.data(), mapping.size()); _foreach (mach_header, fat_header.GetMachHeaders()) { + if (flag_A) { + if (mach_header.GetCPUType() != flag_CPUType) + continue; + if (mach_header.GetCPUSubtype() != flag_CPUSubtype) + continue; + } + mach_header->flags = mach_header.Swap(mach_header.Swap(mach_header->flags) | MH_DYLDLINK); uint32_t size(_not(uint32_t)); { @@ -820,7 +999,7 @@ int main(int argc, const char *argv[]) { _assert(size != _not(uint32_t)); - _foreach (segment, const_cast(mach_header).GetSegments("__LINKEDIT")) { + _foreach (segment, mach_header.GetSegments("__LINKEDIT")) { segment->filesize -= mach_header.GetSize() - size; if (fat_arch *fat_arch = mach_header.GetFatArch()) { @@ -830,7 +1009,7 @@ int main(int argc, const char *argv[]) { clip = std::max(clip, size); } - _foreach (segment, const_cast(mach_header).GetSegments64("__LINKEDIT")) { + _foreach (segment, mach_header.GetSegments64("__LINKEDIT")) { segment->filesize -= mach_header.GetSize() - size; if (fat_arch *fat_arch = mach_header.GetFatArch()) { @@ -842,20 +1021,27 @@ int main(int argc, const char *argv[]) { } } - _assert(clip != 0); - _syscall(truncate(path, clip)); + if (clip != 0) + _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"; + Map input(path, true); + FatHeader source(input.data(), input.size()); + + size_t offset(0); + + if (source.IsFat()) + offset += sizeof(fat_header) + sizeof(fat_arch) * source.Swap(source->nfat_arch); 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); + _foreach (mach_header, source.GetMachHeaders()) { + if (flag_A) { + if (mach_header.GetCPUType() != flag_CPUType) + continue; + if (mach_header.GetCPUSubtype() != flag_CPUSubtype) + continue; + } size_t size(_not(size_t)); { _foreach (load_command, mach_header.GetLoadCommands()) { @@ -872,31 +1058,6 @@ int main(int argc, const char *argv[]) { size = mach_header.GetSize(); } - allocations.push_back(CodesignAllocation(mach_header.GetCPUType(), mach_header.GetCPUSubtype(), size)); - } - } - - pid_t pid = fork(); - _syscall(pid); - if (pid == 0) { - // 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); @@ -904,7 +1065,7 @@ int main(int argc, const char *argv[]) { special = std::max(special, CSSLOT_CODEDIRECTORY); alloc += sizeof(struct BlobIndex); alloc += sizeof(struct CodeDirectory); - alloc += strlen(base) + 1; + alloc += strlen(name) + 1; special = std::max(special, CSSLOT_REQUIREMENTS); alloc += sizeof(struct BlobIndex); @@ -917,46 +1078,118 @@ int main(int argc, const char *argv[]) { alloc += xmls; } - size_t normal((allocation.size_ + 0x1000 - 1) / 0x1000); - alloc += (special + normal) * 0x14; + size_t normal((size + 0x1000 - 1) / 0x1000); + alloc = Align(alloc + (special + normal) * 0x14, 16); - alloc += 15; - alloc /= 16; - alloc *= 16; + auto *fat_arch(mach_header.GetFatArch()); + uint32_t align(fat_arch == NULL ? 0 : source.Swap(fat_arch->align)); + offset = Align(offset, 1 << align); - asprintf(&arg, "%u", alloc); - args.push_back(arg); + allocations.push_back(CodesignAllocation(mach_header, offset, size, alloc, align)); + offset += size + alloc; + offset = Align(offset, 16); } + } + + asprintf(&temp, "%s.%s.cs", dir.c_str(), base); + fclose(fopen(temp, "w+")); + _syscall(truncate(temp, offset)); + + Map output(temp, false); + _assert(output.size() == offset); + void *file(output.data()); + memset(file, 0, offset); + + fat_arch *fat_arch; + if (!source.IsFat()) + fat_arch = NULL; + else { + auto *fat_header(reinterpret_cast(file)); + fat_header->magic = Swap(FAT_MAGIC); + fat_header->nfat_arch = Swap(source.Swap(source->nfat_arch)); + fat_arch = reinterpret_cast(fat_header + 1); + } - args.push_back("-o"); - args.push_back(temp); + _foreach (allocation, allocations) { + auto &source(allocation.mach_header_); - args.push_back(NULL); + uint32_t align(allocation.size_); + align = Align(align, 0x10); - if (false) { - printf("run:"); - _foreach (arg, args) - printf(" %s", arg); - printf("\n"); + if (fat_arch != NULL) { + fat_arch->cputype = Swap(source->cputype); + fat_arch->cpusubtype = Swap(source->cpusubtype); + fat_arch->offset = Swap(allocation.offset_); + fat_arch->size = Swap(align + allocation.alloc_); + fat_arch->align = Swap(allocation.align_); + ++fat_arch; } - execvp(allocate, (char **) &args[0]); - _assert(false); - } + void *target(reinterpret_cast(file) + allocation.offset_); + memcpy(target, source, allocation.size_); + MachHeader mach_header(target, align + allocation.alloc_); - int status; - _syscall(waitpid(pid, &status, 0)); - _assert(WIFEXITED(status)); - _assert(WEXITSTATUS(status) == 0); + struct linkedit_data_command *signature(NULL); + _foreach (load_command, mach_header.GetLoadCommands()) { + uint32_t cmd(mach_header.Swap(load_command->cmd)); + if (cmd != LC_CODE_SIGNATURE) + continue; + signature = reinterpret_cast(load_command); + break; + } + + if (signature == NULL) { + mach_header->ncmds = mach_header.Swap(mach_header.Swap(mach_header->ncmds) + 1); + signature = reinterpret_cast(reinterpret_cast(mach_header.GetLoadCommand()) + mach_header.Swap(mach_header->sizeofcmds)); + mach_header->sizeofcmds = mach_header.Swap(mach_header.Swap(mach_header->sizeofcmds) + uint32_t(sizeof(*signature))); + signature->cmd = mach_header.Swap(LC_CODE_SIGNATURE); + signature->cmdsize = mach_header.Swap(uint32_t(sizeof(*signature))); + } + + signature->dataoff = mach_header.Swap(align); + signature->datasize = mach_header.Swap(allocation.alloc_); + + _foreach (segment, mach_header.GetSegments("__LINKEDIT")) { + size_t size(mach_header.Swap(align + allocation.alloc_ - mach_header.Swap(segment->fileoff))); + segment->filesize = size; + segment->vmsize = Align(size, 0x1000); + } + + _foreach (segment, mach_header.GetSegments64("__LINKEDIT")) { + size_t size(mach_header.Swap(align + allocation.alloc_ - mach_header.Swap(segment->fileoff))); + segment->filesize = size; + segment->vmsize = Align(size, 0x1000); + } + } } if (flag_p) printf("path%zu='%s'\n", filei, file.c_str()); - FatHeader fat_header(Map(temp == NULL ? path : temp, !(flag_R | flag_T | flag_s | flag_S))); - struct linkedit_data_command *signature(NULL); + Map mapping(temp == NULL ? path : temp, !(flag_R || flag_T || flag_s || flag_S || flag_O || flag_D)); + FatHeader fat_header(mapping.data(), mapping.size()); _foreach (mach_header, fat_header.GetMachHeaders()) { + struct linkedit_data_command *signature(NULL); + struct encryption_info_command *encryption(NULL); + + if (flag_A) { + if (mach_header.GetCPUType() != flag_CPUType) + continue; + if (mach_header.GetCPUSubtype() != flag_CPUSubtype) + continue; + } + + if (flag_a) + printf("cpu=0x%x:0x%x\n", mach_header.GetCPUType(), mach_header.GetCPUSubtype()); + + if (flag_d) { + if (struct fat_arch *fat_arch = mach_header.GetFatArch()) + printf("offset=0x%x\n", Swap(fat_arch->offset)); + else + printf("offset=0x0\n"); + } + if (woffset != _not(uintptr_t)) { Pointer wvalue(mach_header.GetPointer(woffset)); if (wvalue == NULL) @@ -968,6 +1201,17 @@ int main(int argc, const char *argv[]) { if (noffset != _not(uintptr_t)) printf("%s\n", &*mach_header.GetPointer(noffset)); + if (flag_d) + _foreach(segment, mach_header.GetSegments("__TEXT")) { + printf("vmaddr=0x%x\n", mach_header.Swap(segment->vmaddr)); + printf("fileoff=0x%x\n", mach_header.Swap(segment->fileoff)); + } + + if (flag_O) { + _foreach(section, mach_header.GetSections("__TEXT", "__text")) + section->addr = mach_header.Swap(0); + } + _foreach (load_command, mach_header.GetLoadCommands()) { uint32_t cmd(mach_header.Swap(load_command->cmd)); @@ -975,6 +1219,8 @@ int main(int argc, const char *argv[]) { load_command->cmd = mach_header.Swap(LC_LOAD_DYLIB); else if (cmd == LC_CODE_SIGNATURE) signature = reinterpret_cast(load_command); + else if (cmd == LC_ENCRYPTION_INFO) + encryption = reinterpret_cast(load_command); else if (cmd == LC_UUID) { volatile struct uuid_command *uuid_command(reinterpret_cast(load_command)); @@ -1007,11 +1253,23 @@ int main(int argc, const char *argv[]) { } } + if (flag_d) { + _assert(encryption != NULL); + + printf("cryptoff=0x%x\n", mach_header.Swap(encryption->cryptoff)); + printf("cryptsize=0x%x\n", mach_header.Swap(encryption->cryptsize)); + printf("cryptid=0x%x\n", mach_header.Swap(encryption->cryptid)); + } + + if (flag_D) { + _assert(encryption != NULL); + encryption->cryptid = mach_header.Swap(0); + } + if (flag_e) { _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; @@ -1029,7 +1287,6 @@ int main(int argc, const char *argv[]) { _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; @@ -1083,8 +1340,8 @@ int main(int argc, const char *argv[]) { directory->spare2 = Swap(uint32_t(0)); directory->identOffset = Swap(offset - begin); - strcpy(reinterpret_cast(blob + offset), base); - offset += strlen(base) + 1; + strcpy(reinterpret_cast(blob + offset), name); + offset += strlen(name) + 1; uint32_t special = xmld == NULL ? CSSLOT_REQUIREMENTS : CSSLOT_ENTITLEMENTS; directory->nSpecialSlots = Swap(special); @@ -1155,7 +1412,7 @@ int main(int argc, const char *argv[]) { size_t size = fat_header.GetSize(); char *copy; - asprintf(©, "%s.%s.cp", dir, base); + asprintf(©, "%s.%s.cp", dir.c_str(), base); FILE *file = fopen(copy, "w+"); size_t writ = fwrite(top, 1, size, file); _assert(writ == size); @@ -1176,7 +1433,6 @@ int main(int argc, const char *argv[]) { free(temp); } - free(dir); ++filei; } catch (const char *) { ++filee;