ldid.cpp

   1 /* JocStrap - Java/Objective-C Bootstrap
   2  * Copyright (C) 2007  Jay Freeman (saurik)
   3 */
   4
   5 /*
   6  *        Redistribution and use in source and binary
   7  * forms, with or without modification, are permitted
   8  * provided that the following conditions are met:
   9  *
  10  * 1. Redistributions of source code must retain the
  11  *    above copyright notice, this list of conditions
  12  *    and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the
  14  *    above copyright notice, this list of conditions
  15  *    and the following disclaimer in the documentation
  16  *    and/or other materials provided with the
  17  *    distribution.
  18  * 3. The name of the author may not be used to endorse
  19  *    or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS''
  23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
  24  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  25  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
  27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  28  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  29  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  30  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  32  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  33  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  34  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  35  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36 */
  37
  38 #include "minimal/stdlib.h"
  39 #include "minimal/mapping.h"
  40
  41 #include "sha1.h"
  42
  43 #include <cstring>
  44 #include <string>
  45 #include <vector>
  46
  47 #include <sys/wait.h>
  48
  49 struct fat_header {
  50     uint32_t magic;
  51     uint32_t nfat_arch;
  52 };
  53
  54 #define FAT_MAGIC 0xcafebabe
  55 #define FAT_CIGAM 0xbebafeca
  56
  57 struct fat_arch {
  58     uint32_t cputype;
  59     uint32_t cpusubtype;
  60     uint32_t offset;
  61     uint32_t size;
  62     uint32_t align;
  63 };
  64
  65 struct mach_header {
  66     uint32_t magic;
  67     uint32_t cputype;
  68     uint32_t cpusubtype;
  69     uint32_t filetype;
  70     uint32_t ncmds;
  71     uint32_t sizeofcmds;
  72     uint32_t flags;
  73 };
  74
  75 #define MH_MAGIC 0xfeedface
  76 #define MH_CIGAM 0xcefaedfe
  77
  78 #define MH_EXECUTE 0x2
  79 #define MH_DYLIB   0x6
  80 #define MH_BUNDLE  0x8
  81
  82 struct load_command {
  83     uint32_t cmd;
  84     uint32_t cmdsize;
  85 };
  86
  87 #define LC_REQ_DYLD  0x80000000
  88
  89 #define LC_LOAD_DYLIB      0x0c
  90 #define LC_ID_DYLIB        0x0d
  91 #define LC_UUID            0x1b
  92 #define LC_CODE_SIGNATURE  0x1d
  93 #define LC_REEXPORT_DYLIB (0x1f | LC_REQ_DYLD)
  94
  95 struct dylib {
  96     uint32_t name;
  97     uint32_t timestamp;
  98     uint32_t current_version;
  99     uint32_t compatibility_version;
 100 };
 101
 102 struct dylib_command {
 103     uint32_t cmd;
 104     uint32_t cmdsize;
 105     struct dylib dylib;
 106 };
 107
 108 struct uuid_command {
 109     uint32_t cmd;
 110     uint32_t cmdsize;
 111     uint8_t uuid[16];
 112 };
 113
 114 struct linkedit_data_command {
 115     uint32_t cmd;
 116     uint32_t cmdsize;
 117     uint32_t dataoff;
 118     uint32_t datasize;
 119 };
 120
 121 uint16_t Swap_(uint16_t value) {
 122     return
 123         ((value >>  8) & 0x00ff) |
 124         ((value <<  8) & 0xff00);
 125 }
 126
 127 uint32_t Swap_(uint32_t value) {
 128     value = ((value >>  8) & 0x00ff00ff) |
 129             ((value <<  8) & 0xff00ff00);
 130     value = ((value >> 16) & 0x0000ffff) |
 131             ((value << 16) & 0xffff0000);
 132     return value;
 133 }
 134
 135 int16_t Swap_(int16_t value) {
 136     return Swap_(static_cast<uint16_t>(value));
 137 }
 138
 139 int32_t Swap_(int32_t value) {
 140     return Swap_(static_cast<uint32_t>(value));
 141 }
 142
 143 uint16_t Swap(uint16_t value) {
 144     return true ? Swap_(value) : value;
 145 }
 146
 147 uint32_t Swap(uint32_t value) {
 148     return true ? Swap_(value) : value;
 149 }
 150
 151 int16_t Swap(int16_t value) {
 152     return Swap(static_cast<uint16_t>(value));
 153 }
 154
 155 int32_t Swap(int32_t value) {
 156     return Swap(static_cast<uint32_t>(value));
 157 }
 158
 159 class Framework {
 160   private:
 161     void *base_;
 162     size_t size_;
 163     mach_header *mach_header_;
 164     bool swapped_;
 165
 166   public:
 167     uint16_t Swap(uint16_t value) const {
 168         return swapped_ ? Swap_(value) : value;
 169     }
 170
 171     uint32_t Swap(uint32_t value) const {
 172         return swapped_ ? Swap_(value) : value;
 173     }
 174
 175     int16_t Swap(int16_t value) const {
 176         return Swap(static_cast<uint16_t>(value));
 177     }
 178
 179     int32_t Swap(int32_t value) const {
 180         return Swap(static_cast<uint32_t>(value));
 181     }
 182
 183     Framework(const char *framework_path) :
 184         swapped_(false)
 185     {
 186         base_ = map(framework_path, 0, _not(size_t), &size_, false);
 187         fat_header *fat_header = reinterpret_cast<struct fat_header *>(base_);
 188
 189         if (Swap(fat_header->magic) == FAT_CIGAM) {
 190             swapped_ = !swapped_;
 191             goto fat;
 192         } else if (Swap(fat_header->magic) != FAT_MAGIC)
 193             mach_header_ = (mach_header *) base_;
 194         else fat: {
 195             size_t fat_narch = Swap(fat_header->nfat_arch);
 196             fat_arch *fat_arch = reinterpret_cast<struct fat_arch *>(fat_header + 1);
 197             size_t arch;
 198             for (arch = 0; arch != fat_narch; ++arch) {
 199                 uint32_t arch_offset = Swap(fat_arch->offset);
 200                 mach_header_ = (mach_header *) ((uint8_t *) base_ + arch_offset);
 201                 goto found;
 202                 ++fat_arch;
 203             }
 204
 205             _assert(false);
 206         }
 207
 208       found:
 209         if (Swap(mach_header_->magic) == MH_CIGAM)
 210             swapped_ = !swapped_;
 211         else _assert(Swap(mach_header_->magic) == MH_MAGIC);
 212
 213         _assert(
 214             Swap(mach_header_->filetype) == MH_EXECUTE ||
 215             Swap(mach_header_->filetype) == MH_DYLIB ||
 216             Swap(mach_header_->filetype) == MH_BUNDLE
 217         );
 218     }
 219
 220     void *GetBase() {
 221         return base_;
 222     }
 223
 224     size_t GetSize() {
 225         return size_;
 226     }
 227
 228     std::vector<struct load_command *> GetLoadCommands() {
 229         std::vector<struct load_command *> load_commands;
 230
 231         struct load_command *load_command = reinterpret_cast<struct load_command *>(mach_header_ + 1);
 232         for (uint32_t cmd = 0; cmd != Swap(mach_header_->ncmds); ++cmd) {
 233             load_commands.push_back(load_command);
 234             load_command = (struct load_command *) ((uint8_t *) load_command + Swap(load_command->cmdsize));
 235         }
 236
 237         return load_commands;
 238     }
 239 };
 240
 241 #define CSMAGIC_CODEDIRECTORY 0xfade0c02
 242 #define CSMAGIC_EMBEDDED_SIGNATURE 0xfade0cc0
 243 #define CSSLOT_CODEDIRECTORY 0
 244
 245 struct BlobIndex {
 246     uint32_t type;
 247     uint32_t offset;
 248 };
 249
 250 struct SuperBlob {
 251     uint32_t magic;
 252     uint32_t length;
 253     uint32_t count;
 254     struct BlobIndex index[];
 255 };
 256
 257 struct CodeDirectory {
 258     uint32_t magic;
 259     uint32_t length;
 260     uint32_t version;
 261     uint32_t flags;
 262     uint32_t hashOffset;
 263     uint32_t identOffset;
 264     uint32_t nSpecialSlots;
 265     uint32_t nCodeSlots;
 266     uint32_t codeLimit;
 267     uint8_t hashSize;
 268     uint8_t hashType;
 269     uint8_t spare1;
 270     uint8_t pageSize;
 271     uint32_t spare2;
 272 };
 273
 274 extern "C" uint32_t hash(uint8_t *k, uint32_t length, uint32_t initval);
 275
 276 #define CODESIGN_ALLOCATE "arm-apple-darwin9-codesign_allocate"
 277
 278 void sha1(uint8_t *hash, uint8_t *data, size_t size) {
 279     SHA1Context context;
 280     SHA1Reset(&context);
 281     SHA1Input(&context, data, size);
 282     SHA1Result(&context, hash);
 283 }
 284
 285 int main(int argc, const char *argv[]) {
 286     bool flag_R(false);
 287     bool flag_t(false);
 288     bool flag_p(false);
 289     bool flag_u(false);
 290
 291     bool flag_T(false);
 292     bool flag_S(false);
 293
 294     bool timeh(false);
 295     uint32_t timev(0);
 296
 297     std::vector<std::string> files;
 298
 299     _assert(argc != 0);
 300     for (int argi(1); argi != argc; ++argi)
 301         if (argv[argi][0] != '-')
 302             files.push_back(argv[argi]);
 303         else switch (argv[argi][1]) {
 304             case 'R': flag_R = true; break;
 305             case 't': flag_t = true; break;
 306             case 'u': flag_u = true; break;
 307             case 'p': flag_p = true; break;
 308             case 'S': flag_S = true; break;
 309
 310             case 'T': {
 311                 flag_T = true;
 312                 if (argv[argi][2] == '-')
 313                     timeh = true;
 314                 else {
 315                     char *arge;
 316                     timev = strtoul(argv[argi] + 2, &arge, 0);
 317                     _assert(arge == argv[argi] + strlen(argv[argi]));
 318                 }
 319             } break;
 320
 321             default:
 322                 goto usage;
 323             break;
 324         }
 325
 326     if (files.empty()) usage: {
 327         exit(0);
 328     }
 329
 330     size_t filei(0), filee(0);
 331     _foreach (file, files) try {
 332         const char *path(file->c_str());
 333         const char *base = strrchr(path, '/');
 334         char *temp(NULL), *dir;
 335
 336         if (base != NULL)
 337             dir = strndup(path, base++ - path + 1);
 338         else {
 339             dir = strdup("");
 340             base = path;
 341         }
 342
 343         if (flag_S) {
 344             asprintf(&temp, "%s.%s.cs", dir, base);
 345             const char *allocate = getenv("CODESIGN_ALLOCATE");
 346             if (allocate == NULL)
 347                 allocate = "codesign_allocate";
 348
 349             size_t size; {
 350                 Framework framework(path);
 351                 size = framework.GetSize();
 352             }
 353
 354             pid_t pid = fork();
 355             _syscall(pid);
 356             if (pid == 0) {
 357                 char *ssize;
 358                 asprintf(&ssize, "%u", (sizeof(struct SuperBlob) + sizeof(struct BlobIndex) + sizeof(struct CodeDirectory) + strlen(base) + 1 + (size + 0x1000 - 1) / 0x1000 * 0x14 + 15) / 16 * 16);
 359                 printf("%s\n", ssize);
 360                 execlp(allocate, allocate, "-i", path, "-a", "arm", ssize, "-o", temp, NULL);
 361                 _assert(false);
 362             }
 363
 364             int status;
 365             _syscall(waitpid(pid, &status, 0));
 366             _assert(WIFEXITED(status));
 367             _assert(WEXITSTATUS(status) == 0);
 368         }
 369
 370         Framework framework(temp == NULL ? path : temp);
 371         struct linkedit_data_command *signature(NULL);
 372
 373         if (flag_p)
 374             printf("path%zu='%s'\n", filei, file->c_str());
 375
 376         _foreach (load_command, framework.GetLoadCommands()) {
 377             uint32_t cmd(framework.Swap((*load_command)->cmd));
 378
 379             if (flag_R && cmd == LC_REEXPORT_DYLIB)
 380                 (*load_command)->cmd = framework.Swap(LC_LOAD_DYLIB);
 381             else if (cmd == LC_CODE_SIGNATURE)
 382                 signature = reinterpret_cast<struct linkedit_data_command *>(*load_command);
 383             else if (cmd == LC_UUID) {
 384                 volatile struct uuid_command *uuid_command(reinterpret_cast<struct uuid_command *>(*load_command));
 385
 386                 if (flag_u) {
 387                     printf("uuid%zu=%.2x%.2x%.2x%.2x-%.2x%.2x-%.2x%.2x-%.2x%.2x-%.2x%.2x%.2x%.2x%.2x%.2x\n", filei,
 388                         uuid_command->uuid[ 0], uuid_command->uuid[ 1], uuid_command->uuid[ 2], uuid_command->uuid[ 3],
 389                         uuid_command->uuid[ 4], uuid_command->uuid[ 5], uuid_command->uuid[ 6], uuid_command->uuid[ 7],
 390                         uuid_command->uuid[ 8], uuid_command->uuid[ 9], uuid_command->uuid[10], uuid_command->uuid[11],
 391                         uuid_command->uuid[12], uuid_command->uuid[13], uuid_command->uuid[14], uuid_command->uuid[15]
 392                     );
 393                 }
 394             } else if (cmd == LC_ID_DYLIB) {
 395                 volatile struct dylib_command *dylib_command(reinterpret_cast<struct dylib_command *>(*load_command));
 396
 397                 if (flag_t)
 398                     printf("time%zu=0x%.8x\n", filei, framework.Swap(dylib_command->dylib.timestamp));
 399
 400                 if (flag_T) {
 401                     uint32_t timed;
 402
 403                     if (!timeh)
 404                         timed = timev;
 405                     else {
 406                         dylib_command->dylib.timestamp = 0;
 407                         timed = hash(reinterpret_cast<uint8_t *>(framework.GetBase()), framework.GetSize(), timev);
 408                     }
 409
 410                     dylib_command->dylib.timestamp = framework.Swap(timed);
 411                 }
 412             }
 413         }
 414
 415         if (flag_S) {
 416             _assert(signature != NULL);
 417
 418             uint32_t data = framework.Swap(signature->dataoff);
 419             uint32_t size = framework.Swap(signature->datasize);
 420
 421             uint8_t *top = reinterpret_cast<uint8_t *>(framework.GetBase());
 422             uint8_t *blob = top + data;
 423             struct SuperBlob *super = reinterpret_cast<struct SuperBlob *>(blob);
 424             super->magic = Swap(CSMAGIC_EMBEDDED_SIGNATURE);
 425
 426             uint32_t count = 1;
 427             uint32_t offset = sizeof(struct SuperBlob) + count * sizeof(struct BlobIndex);
 428
 429             super->index[0].type = Swap(CSSLOT_CODEDIRECTORY);
 430             super->index[0].offset = Swap(offset);
 431
 432             uint32_t begin = offset;
 433             struct CodeDirectory *directory = reinterpret_cast<struct CodeDirectory *>(blob + begin);
 434             offset += sizeof(struct CodeDirectory);
 435
 436             directory->magic = Swap(CSMAGIC_CODEDIRECTORY);
 437             directory->version = Swap(0x00020001);
 438             directory->flags = Swap(0);
 439             directory->codeLimit = Swap(data);
 440             directory->hashSize = 0x14;
 441             directory->hashType = 0x01;
 442             directory->spare1 = 0x00;
 443             directory->pageSize = 0x0c;
 444             directory->spare2 = Swap(0);
 445
 446             directory->identOffset = Swap(offset - begin);
 447             strcpy(reinterpret_cast<char *>(blob + offset), base);
 448             offset += strlen(base) + 1;
 449
 450             uint8_t (*hashes)[20] = reinterpret_cast<uint8_t (*)[20]>(blob + offset);
 451             uint32_t special = 0;
 452
 453             uint32_t pages = (data + 0x1000 - 1) / 0x1000;
 454             directory->nSpecialSlots = Swap(special);
 455             directory->nCodeSlots = Swap(pages);
 456
 457             if (pages != 1)
 458                 for (size_t i = 0; i != pages - 1; ++i)
 459                     sha1(hashes[special + i], top + 0x1000 * i, 0x1000);
 460             if (pages != 0)
 461                 sha1(hashes[special + pages - 1], top + 0x1000 * (pages - 1), data % 0x1000);
 462
 463             directory->hashOffset = Swap(offset - begin);
 464             offset += sizeof(*hashes) * (special + pages);
 465             directory->length = Swap(offset - begin);
 466
 467             super->count = Swap(count);
 468             super->length = Swap(offset);
 469
 470             _assert(offset < size);
 471             memset(blob + offset, 0, size - offset);
 472         }
 473
 474         if (temp) {
 475             _syscall(unlink(path));
 476             _syscall(rename(temp, path));
 477             free(temp);
 478         }
 479
 480         free(dir);
 481         ++filei;
 482     } catch (const char *) {
 483         ++filee;
 484         ++filei;
 485     }
 486
 487     return filee;
 488 }