]> git.saurik.com Git - ldid.git/blob - ldid.cpp
projects / ldid.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Simplify implementation of temporary reallocation.
[ldid.git] / ldid.cpp
1 /* ldid - (Mach-O) Link-Loader Identity Editor
2 * Copyright (C) 2007-2015 Jay Freeman (saurik)
3 */
4
5 /* GNU Affero General Public License, Version 3 {{{ */
6 /*
7 * This program is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU Affero General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU Affero General Public License for more details.
16
17 * You should have received a copy of the GNU Affero General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 **/
20 /* }}} */
21
22 #include <cstdio>
23 #include <cstdlib>
24 #include <cstring>
25 #include <fstream>
26 #include <map>
27 #include <sstream>
28 #include <string>
29 #include <vector>
30
31 #include <errno.h>
32 #include <fcntl.h>
33 #include <stdbool.h>
34 #include <stdint.h>
35 #include <unistd.h>
36
37 #include <sys/mman.h>
38 #include <sys/stat.h>
39
40 #include <openssl/err.h>
41 #include <openssl/pem.h>
42 #include <openssl/pkcs7.h>
43 #include <openssl/pkcs12.h>
44 #include <openssl/sha.h>
45
46 #include <plist/plist.h>
47
48 #define _assert___(line) \
49 #line
50 #define _assert__(line) \
51 _assert___(line)
52 #define _assert_(e) \
53 throw __FILE__ "(" _assert__(__LINE__) "): _assert(" e ")"
54
55 #define _assert(expr) \
56 do if (!(expr)) { \
57 fprintf(stderr, "%s(%u): _assert(%s); errno=%u\n", __FILE__, __LINE__, #expr, errno); \
58 _assert_(#expr); \
59 } while (false)
60
61 #define _syscall(expr) ({ \
62 __typeof__(expr) _value; \
63 do if ((long) (_value = (expr)) != -1) \
64 break; \
65 else switch (errno) { \
66 case EINTR: \
67 continue; \
68 default: \
69 _assert(false); \
70 } while (true); \
71 _value; \
72 })
73
74 #define _trace() \
75 fprintf(stderr, "_trace(%s:%u): %s\n", __FILE__, __LINE__, __FUNCTION__)
76
77 #define _not(type) \
78 ((type) ~ (type) 0)
79
80 #define _packed \
81 __attribute__((packed))
82
83 template <typename Type_>
84 struct Iterator_ {
85 typedef typename Type_::const_iterator Result;
86 };
87
88 #define _foreach(item, list) \
89 for (bool _stop(true); _stop; ) \
90 for (const __typeof__(list) &_list = (list); _stop; _stop = false) \
91 for (Iterator_<__typeof__(list)>::Result _item = _list.begin(); _item != _list.end(); ++_item) \
92 for (bool _suck(true); _suck; _suck = false) \
93 for (const __typeof__(*_item) &item = *_item; _suck; _suck = false)
94
95 struct fat_header {
96 uint32_t magic;
97 uint32_t nfat_arch;
98 } _packed;
99
100 #define FAT_MAGIC 0xcafebabe
101 #define FAT_CIGAM 0xbebafeca
102
103 struct fat_arch {
104 uint32_t cputype;
105 uint32_t cpusubtype;
106 uint32_t offset;
107 uint32_t size;
108 uint32_t align;
109 } _packed;
110
111 struct mach_header {
112 uint32_t magic;
113 uint32_t cputype;
114 uint32_t cpusubtype;
115 uint32_t filetype;
116 uint32_t ncmds;
117 uint32_t sizeofcmds;
118 uint32_t flags;
119 } _packed;
120
121 #define MH_MAGIC 0xfeedface
122 #define MH_CIGAM 0xcefaedfe
123
124 #define MH_MAGIC_64 0xfeedfacf
125 #define MH_CIGAM_64 0xcffaedfe
126
127 #define MH_DYLDLINK 0x4
128
129 #define MH_OBJECT 0x1
130 #define MH_EXECUTE 0x2
131 #define MH_DYLIB 0x6
132 #define MH_BUNDLE 0x8
133 #define MH_DYLIB_STUB 0x9
134
135 struct load_command {
136 uint32_t cmd;
137 uint32_t cmdsize;
138 } _packed;
139
140 #define LC_REQ_DYLD uint32_t(0x80000000)
141
142 #define LC_SEGMENT uint32_t(0x01)
143 #define LC_SYMTAB uint32_t(0x02)
144 #define LC_DYSYMTAB uint32_t(0x0b)
145 #define LC_LOAD_DYLIB uint32_t(0x0c)
146 #define LC_ID_DYLIB uint32_t(0x0d)
147 #define LC_SEGMENT_64 uint32_t(0x19)
148 #define LC_UUID uint32_t(0x1b)
149 #define LC_CODE_SIGNATURE uint32_t(0x1d)
150 #define LC_SEGMENT_SPLIT_INFO uint32_t(0x1e)
151 #define LC_REEXPORT_DYLIB uint32_t(0x1f | LC_REQ_DYLD)
152 #define LC_ENCRYPTION_INFO uint32_t(0x21)
153 #define LC_DYLD_INFO uint32_t(0x22)
154 #define LC_DYLD_INFO_ONLY uint32_t(0x22 | LC_REQ_DYLD)
155 #define LC_ENCRYPTION_INFO_64 uint32_t(0x2c)
156
157 struct dylib {
158 uint32_t name;
159 uint32_t timestamp;
160 uint32_t current_version;
161 uint32_t compatibility_version;
162 } _packed;
163
164 struct dylib_command {
165 uint32_t cmd;
166 uint32_t cmdsize;
167 struct dylib dylib;
168 } _packed;
169
170 struct uuid_command {
171 uint32_t cmd;
172 uint32_t cmdsize;
173 uint8_t uuid[16];
174 } _packed;
175
176 struct symtab_command {
177 uint32_t cmd;
178 uint32_t cmdsize;
179 uint32_t symoff;
180 uint32_t nsyms;
181 uint32_t stroff;
182 uint32_t strsize;
183 } _packed;
184
185 struct dyld_info_command {
186 uint32_t cmd;
187 uint32_t cmdsize;
188 uint32_t rebase_off;
189 uint32_t rebase_size;
190 uint32_t bind_off;
191 uint32_t bind_size;
192 uint32_t weak_bind_off;
193 uint32_t weak_bind_size;
194 uint32_t lazy_bind_off;
195 uint32_t lazy_bind_size;
196 uint32_t export_off;
197 uint32_t export_size;
198 } _packed;
199
200 struct dysymtab_command {
201 uint32_t cmd;
202 uint32_t cmdsize;
203 uint32_t ilocalsym;
204 uint32_t nlocalsym;
205 uint32_t iextdefsym;
206 uint32_t nextdefsym;
207 uint32_t iundefsym;
208 uint32_t nundefsym;
209 uint32_t tocoff;
210 uint32_t ntoc;
211 uint32_t modtaboff;
212 uint32_t nmodtab;
213 uint32_t extrefsymoff;
214 uint32_t nextrefsyms;
215 uint32_t indirectsymoff;
216 uint32_t nindirectsyms;
217 uint32_t extreloff;
218 uint32_t nextrel;
219 uint32_t locreloff;
220 uint32_t nlocrel;
221 } _packed;
222
223 struct dylib_table_of_contents {
224 uint32_t symbol_index;
225 uint32_t module_index;
226 } _packed;
227
228 struct dylib_module {
229 uint32_t module_name;
230 uint32_t iextdefsym;
231 uint32_t nextdefsym;
232 uint32_t irefsym;
233 uint32_t nrefsym;
234 uint32_t ilocalsym;
235 uint32_t nlocalsym;
236 uint32_t iextrel;
237 uint32_t nextrel;
238 uint32_t iinit_iterm;
239 uint32_t ninit_nterm;
240 uint32_t objc_module_info_addr;
241 uint32_t objc_module_info_size;
242 } _packed;
243
244 struct dylib_reference {
245 uint32_t isym:24;
246 uint32_t flags:8;
247 } _packed;
248
249 struct relocation_info {
250 int32_t r_address;
251 uint32_t r_symbolnum:24;
252 uint32_t r_pcrel:1;
253 uint32_t r_length:2;
254 uint32_t r_extern:1;
255 uint32_t r_type:4;
256 } _packed;
257
258 struct nlist {
259 union {
260 char *n_name;
261 int32_t n_strx;
262 } n_un;
263
264 uint8_t n_type;
265 uint8_t n_sect;
266 uint8_t n_desc;
267 uint32_t n_value;
268 } _packed;
269
270 struct segment_command {
271 uint32_t cmd;
272 uint32_t cmdsize;
273 char segname[16];
274 uint32_t vmaddr;
275 uint32_t vmsize;
276 uint32_t fileoff;
277 uint32_t filesize;
278 uint32_t maxprot;
279 uint32_t initprot;
280 uint32_t nsects;
281 uint32_t flags;
282 } _packed;
283
284 struct segment_command_64 {
285 uint32_t cmd;
286 uint32_t cmdsize;
287 char segname[16];
288 uint64_t vmaddr;
289 uint64_t vmsize;
290 uint64_t fileoff;
291 uint64_t filesize;
292 uint32_t maxprot;
293 uint32_t initprot;
294 uint32_t nsects;
295 uint32_t flags;
296 } _packed;
297
298 struct section {
299 char sectname[16];
300 char segname[16];
301 uint32_t addr;
302 uint32_t size;
303 uint32_t offset;
304 uint32_t align;
305 uint32_t reloff;
306 uint32_t nreloc;
307 uint32_t flags;
308 uint32_t reserved1;
309 uint32_t reserved2;
310 } _packed;
311
312 struct section_64 {
313 char sectname[16];
314 char segname[16];
315 uint64_t addr;
316 uint64_t size;
317 uint32_t offset;
318 uint32_t align;
319 uint32_t reloff;
320 uint32_t nreloc;
321 uint32_t flags;
322 uint32_t reserved1;
323 uint32_t reserved2;
324 } _packed;
325
326 struct linkedit_data_command {
327 uint32_t cmd;
328 uint32_t cmdsize;
329 uint32_t dataoff;
330 uint32_t datasize;
331 } _packed;
332
333 struct encryption_info_command {
334 uint32_t cmd;
335 uint32_t cmdsize;
336 uint32_t cryptoff;
337 uint32_t cryptsize;
338 uint32_t cryptid;
339 } _packed;
340
341 #define BIND_OPCODE_MASK 0xf0
342 #define BIND_IMMEDIATE_MASK 0x0f
343 #define BIND_OPCODE_DONE 0x00
344 #define BIND_OPCODE_SET_DYLIB_ORDINAL_IMM 0x10
345 #define BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB 0x20
346 #define BIND_OPCODE_SET_DYLIB_SPECIAL_IMM 0x30
347 #define BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM 0x40
348 #define BIND_OPCODE_SET_TYPE_IMM 0x50
349 #define BIND_OPCODE_SET_ADDEND_SLEB 0x60
350 #define BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB 0x70
351 #define BIND_OPCODE_ADD_ADDR_ULEB 0x80
352 #define BIND_OPCODE_DO_BIND 0x90
353 #define BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB 0xa0
354 #define BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED 0xb0
355 #define BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB 0xc0
356
357 inline void get(std::streambuf &stream, void *data, size_t size) {
358 _assert(stream.sgetn(static_cast<char *>(data), size) == size);
359 }
360
361 inline void put(std::streambuf &stream, const void *data, size_t size) {
362 _assert(stream.sputn(static_cast<const char *>(data), size) == size);
363 }
364
365 inline void pad(std::streambuf &stream, size_t size) {
366 char padding[size];
367 memset(padding, 0, size);
368 put(stream, padding, size);
369 }
370
371 template <typename Type_>
372 Type_ Align(Type_ value, size_t align) {
373 value += align - 1;
374 value /= align;
375 value *= align;
376 return value;
377 }
378
379 static const uint8_t PageShift_(0x0c);
380 static const uint32_t PageSize_(1 << PageShift_);
381
382 static inline uint16_t Swap_(uint16_t value) {
383 return
384 ((value >> 8) & 0x00ff) |
385 ((value << 8) & 0xff00);
386 }
387
388 static inline uint32_t Swap_(uint32_t value) {
389 value = ((value >> 8) & 0x00ff00ff) |
390 ((value << 8) & 0xff00ff00);
391 value = ((value >> 16) & 0x0000ffff) |
392 ((value << 16) & 0xffff0000);
393 return value;
394 }
395
396 static inline uint64_t Swap_(uint64_t value) {
397 value = (value & 0x00000000ffffffff) << 32 | (value & 0xffffffff00000000) >> 32;
398 value = (value & 0x0000ffff0000ffff) << 16 | (value & 0xffff0000ffff0000) >> 16;
399 value = (value & 0x00ff00ff00ff00ff) << 8 | (value & 0xff00ff00ff00ff00) >> 8;
400 return value;
401 }
402
403 static inline int16_t Swap_(int16_t value) {
404 return Swap_(static_cast<uint16_t>(value));
405 }
406
407 static inline int32_t Swap_(int32_t value) {
408 return Swap_(static_cast<uint32_t>(value));
409 }
410
411 static inline int64_t Swap_(int64_t value) {
412 return Swap_(static_cast<uint64_t>(value));
413 }
414
415 static bool little_(true);
416
417 static inline uint16_t Swap(uint16_t value) {
418 return little_ ? Swap_(value) : value;
419 }
420
421 static inline uint32_t Swap(uint32_t value) {
422 return little_ ? Swap_(value) : value;
423 }
424
425 static inline uint64_t Swap(uint64_t value) {
426 return little_ ? Swap_(value) : value;
427 }
428
429 static inline int16_t Swap(int16_t value) {
430 return Swap(static_cast<uint16_t>(value));
431 }
432
433 static inline int32_t Swap(int32_t value) {
434 return Swap(static_cast<uint32_t>(value));
435 }
436
437 static inline int64_t Swap(int64_t value) {
438 return Swap(static_cast<uint64_t>(value));
439 }
440
441 template <typename Target_>
442 class Pointer;
443
444 class Swapped {
445 protected:
446 bool swapped_;
447
448 Swapped() :
449 swapped_(false)
450 {
451 }
452
453 public:
454 Swapped(bool swapped) :
455 swapped_(swapped)
456 {
457 }
458
459 template <typename Type_>
460 Type_ Swap(Type_ value) const {
461 return swapped_ ? Swap_(value) : value;
462 }
463 };
464
465 class Data :
466 public Swapped
467 {
468 private:
469 void *base_;
470 size_t size_;
471
472 public:
473 Data(void *base, size_t size) :
474 base_(base),
475 size_(size)
476 {
477 }
478
479 void *GetBase() const {
480 return base_;
481 }
482
483 size_t GetSize() const {
484 return size_;
485 }
486 };
487
488 class MachHeader :
489 public Data
490 {
491 private:
492 bool bits64_;
493
494 struct mach_header *mach_header_;
495 struct load_command *load_command_;
496
497 public:
498 MachHeader(void *base, size_t size) :
499 Data(base, size)
500 {
501 mach_header_ = (mach_header *) base;
502
503 switch (Swap(mach_header_->magic)) {
504 case MH_CIGAM:
505 swapped_ = !swapped_;
506 case MH_MAGIC:
507 bits64_ = false;
508 break;
509
510 case MH_CIGAM_64:
511 swapped_ = !swapped_;
512 case MH_MAGIC_64:
513 bits64_ = true;
514 break;
515
516 default:
517 _assert(false);
518 }
519
520 void *post = mach_header_ + 1;
521 if (bits64_)
522 post = (uint32_t *) post + 1;
523 load_command_ = (struct load_command *) post;
524
525 _assert(
526 Swap(mach_header_->filetype) == MH_EXECUTE ||
527 Swap(mach_header_->filetype) == MH_DYLIB ||
528 Swap(mach_header_->filetype) == MH_BUNDLE
529 );
530 }
531
532 bool Bits64() const {
533 return bits64_;
534 }
535
536 struct mach_header *operator ->() const {
537 return mach_header_;
538 }
539
540 operator struct mach_header *() const {
541 return mach_header_;
542 }
543
544 uint32_t GetCPUType() const {
545 return Swap(mach_header_->cputype);
546 }
547
548 uint32_t GetCPUSubtype() const {
549 return Swap(mach_header_->cpusubtype) & 0xff;
550 }
551
552 struct load_command *GetLoadCommand() const {
553 return load_command_;
554 }
555
556 std::vector<struct load_command *> GetLoadCommands() const {
557 std::vector<struct load_command *> load_commands;
558
559 struct load_command *load_command = load_command_;
560 for (uint32_t cmd = 0; cmd != Swap(mach_header_->ncmds); ++cmd) {
561 load_commands.push_back(load_command);
562 load_command = (struct load_command *) ((uint8_t *) load_command + Swap(load_command->cmdsize));
563 }
564
565 return load_commands;
566 }
567
568 std::vector<segment_command *> GetSegments(const char *segment_name) const {
569 std::vector<struct segment_command *> segment_commands;
570
571 _foreach (load_command, GetLoadCommands()) {
572 if (Swap(load_command->cmd) == LC_SEGMENT) {
573 segment_command *segment_command = reinterpret_cast<struct segment_command *>(load_command);
574 if (strncmp(segment_command->segname, segment_name, 16) == 0)
575 segment_commands.push_back(segment_command);
576 }
577 }
578
579 return segment_commands;
580 }
581
582 std::vector<segment_command_64 *> GetSegments64(const char *segment_name) const {
583 std::vector<struct segment_command_64 *> segment_commands;
584
585 _foreach (load_command, GetLoadCommands()) {
586 if (Swap(load_command->cmd) == LC_SEGMENT_64) {
587 segment_command_64 *segment_command = reinterpret_cast<struct segment_command_64 *>(load_command);
588 if (strncmp(segment_command->segname, segment_name, 16) == 0)
589 segment_commands.push_back(segment_command);
590 }
591 }
592
593 return segment_commands;
594 }
595
596 std::vector<section *> GetSections(const char *segment_name, const char *section_name) const {
597 std::vector<section *> sections;
598
599 _foreach (segment, GetSegments(segment_name)) {
600 section *section = (struct section *) (segment + 1);
601
602 uint32_t sect;
603 for (sect = 0; sect != Swap(segment->nsects); ++sect) {
604 if (strncmp(section->sectname, section_name, 16) == 0)
605 sections.push_back(section);
606 ++section;
607 }
608 }
609
610 return sections;
611 }
612
613 template <typename Target_>
614 Pointer<Target_> GetPointer(uint32_t address, const char *segment_name = NULL) const {
615 load_command *load_command = (struct load_command *) (mach_header_ + 1);
616 uint32_t cmd;
617
618 for (cmd = 0; cmd != Swap(mach_header_->ncmds); ++cmd) {
619 if (Swap(load_command->cmd) == LC_SEGMENT) {
620 segment_command *segment_command = (struct segment_command *) load_command;
621 if (segment_name != NULL && strncmp(segment_command->segname, segment_name, 16) != 0)
622 goto next_command;
623
624 section *sections = (struct section *) (segment_command + 1);
625
626 uint32_t sect;
627 for (sect = 0; sect != Swap(segment_command->nsects); ++sect) {
628 section *section = &sections[sect];
629 //printf("%s %u %p %p %u\n", segment_command->segname, sect, address, section->addr, section->size);
630 if (address >= Swap(section->addr) && address < Swap(section->addr) + Swap(section->size)) {
631 //printf("0x%.8x %s\n", address, segment_command->segname);
632 return Pointer<Target_>(this, reinterpret_cast<Target_ *>(address - Swap(section->addr) + Swap(section->offset) + (char *) mach_header_));
633 }
634 }
635 }
636
637 next_command:
638 load_command = (struct load_command *) ((char *) load_command + Swap(load_command->cmdsize));
639 }
640
641 return Pointer<Target_>(this);
642 }
643
644 template <typename Target_>
645 Pointer<Target_> GetOffset(uint32_t offset) {
646 return Pointer<Target_>(this, reinterpret_cast<Target_ *>(offset + (uint8_t *) mach_header_));
647 }
648 };
649
650 class FatMachHeader :
651 public MachHeader
652 {
653 private:
654 fat_arch *fat_arch_;
655
656 public:
657 FatMachHeader(void *base, size_t size, fat_arch *fat_arch) :
658 MachHeader(base, size),
659 fat_arch_(fat_arch)
660 {
661 }
662
663 fat_arch *GetFatArch() const {
664 return fat_arch_;
665 }
666 };
667
668 class FatHeader :
669 public Data
670 {
671 private:
672 fat_header *fat_header_;
673 std::vector<FatMachHeader> mach_headers_;
674
675 public:
676 FatHeader(void *base, size_t size) :
677 Data(base, size)
678 {
679 fat_header_ = reinterpret_cast<struct fat_header *>(base);
680
681 if (Swap(fat_header_->magic) == FAT_CIGAM) {
682 swapped_ = !swapped_;
683 goto fat;
684 } else if (Swap(fat_header_->magic) != FAT_MAGIC) {
685 fat_header_ = NULL;
686 mach_headers_.push_back(FatMachHeader(base, size, NULL));
687 } else fat: {
688 size_t fat_narch = Swap(fat_header_->nfat_arch);
689 fat_arch *fat_arch = reinterpret_cast<struct fat_arch *>(fat_header_ + 1);
690 size_t arch;
691 for (arch = 0; arch != fat_narch; ++arch) {
692 uint32_t arch_offset = Swap(fat_arch->offset);
693 uint32_t arch_size = Swap(fat_arch->size);
694 mach_headers_.push_back(FatMachHeader((uint8_t *) base + arch_offset, arch_size, fat_arch));
695 ++fat_arch;
696 }
697 }
698 }
699
700 std::vector<FatMachHeader> &GetMachHeaders() {
701 return mach_headers_;
702 }
703
704 bool IsFat() const {
705 return fat_header_ != NULL;
706 }
707
708 struct fat_header *operator ->() const {
709 return fat_header_;
710 }
711
712 operator struct fat_header *() const {
713 return fat_header_;
714 }
715 };
716
717 template <typename Target_>
718 class Pointer {
719 private:
720 const MachHeader *framework_;
721 const Target_ *pointer_;
722
723 public:
724 Pointer(const MachHeader *framework = NULL, const Target_ *pointer = NULL) :
725 framework_(framework),
726 pointer_(pointer)
727 {
728 }
729
730 operator const Target_ *() const {
731 return pointer_;
732 }
733
734 const Target_ *operator ->() const {
735 return pointer_;
736 }
737
738 Pointer<Target_> &operator ++() {
739 ++pointer_;
740 return *this;
741 }
742
743 template <typename Value_>
744 Value_ Swap(Value_ value) {
745 return framework_->Swap(value);
746 }
747 };
748
749 #define CSMAGIC_REQUIREMENT uint32_t(0xfade0c00)
750 #define CSMAGIC_REQUIREMENTS uint32_t(0xfade0c01)
751 #define CSMAGIC_CODEDIRECTORY uint32_t(0xfade0c02)
752 #define CSMAGIC_EMBEDDED_SIGNATURE uint32_t(0xfade0cc0)
753 #define CSMAGIC_EMBEDDED_SIGNATURE_OLD uint32_t(0xfade0b02)
754 #define CSMAGIC_EMBEDDED_ENTITLEMENTS uint32_t(0xfade7171)
755 #define CSMAGIC_DETACHED_SIGNATURE uint32_t(0xfade0cc1)
756 #define CSMAGIC_BLOBWRAPPER uint32_t(0xfade0b01)
757
758 #define CSSLOT_CODEDIRECTORY uint32_t(0x00000)
759 #define CSSLOT_INFOSLOT uint32_t(0x00001)
760 #define CSSLOT_REQUIREMENTS uint32_t(0x00002)
761 #define CSSLOT_RESOURCEDIR uint32_t(0x00003)
762 #define CSSLOT_APPLICATION uint32_t(0x00004)
763 #define CSSLOT_ENTITLEMENTS uint32_t(0x00005)
764
765 #define CSSLOT_SIGNATURESLOT uint32_t(0x10000)
766
767 #define CS_HASHTYPE_SHA1 1
768
769 struct BlobIndex {
770 uint32_t type;
771 uint32_t offset;
772 } _packed;
773
774 struct Blob {
775 uint32_t magic;
776 uint32_t length;
777 } _packed;
778
779 struct SuperBlob {
780 struct Blob blob;
781 uint32_t count;
782 struct BlobIndex index[];
783 } _packed;
784
785 struct CodeDirectory {
786 uint32_t version;
787 uint32_t flags;
788 uint32_t hashOffset;
789 uint32_t identOffset;
790 uint32_t nSpecialSlots;
791 uint32_t nCodeSlots;
792 uint32_t codeLimit;
793 uint8_t hashSize;
794 uint8_t hashType;
795 uint8_t spare1;
796 uint8_t pageSize;
797 uint32_t spare2;
798 } _packed;
799
800 extern "C" uint32_t hash(uint8_t *k, uint32_t length, uint32_t initval);
801
802 static void sha1(uint8_t *hash, const void *data, size_t size) {
803 SHA1(static_cast<const uint8_t *>(data), size, hash);
804 }
805
806 struct CodesignAllocation {
807 FatMachHeader mach_header_;
808 uint32_t offset_;
809 uint32_t size_;
810 uint32_t limit_;
811 uint32_t alloc_;
812 uint32_t align_;
813
814 CodesignAllocation(FatMachHeader mach_header, size_t offset, size_t size, size_t limit, size_t alloc, size_t align) :
815 mach_header_(mach_header),
816 offset_(offset),
817 size_(size),
818 limit_(limit),
819 alloc_(alloc),
820 align_(align)
821 {
822 }
823 };
824
825 class File {
826 private:
827 int file_;
828
829 public:
830 File() :
831 file_(-1)
832 {
833 }
834
835 ~File() {
836 if (file_ != -1)
837 _syscall(close(file_));
838 }
839
840 void open(const char *path, int flags) {
841 _assert(file_ == -1);
842 _syscall(file_ = ::open(path, flags));
843 }
844
845 int file() const {
846 return file_;
847 }
848 };
849
850 class Map {
851 private:
852 File file_;
853 void *data_;
854 size_t size_;
855
856 void clear() {
857 if (data_ == NULL)
858 return;
859 _syscall(munmap(data_, size_));
860 data_ = NULL;
861 size_ = 0;
862 }
863
864 public:
865 Map() :
866 data_(NULL),
867 size_(0)
868 {
869 }
870
871 Map(const char *path, int oflag, int pflag, int mflag) :
872 Map()
873 {
874 open(path, oflag, pflag, mflag);
875 }
876
877 Map(const char *path, bool edit) :
878 Map()
879 {
880 open(path, edit);
881 }
882
883 ~Map() {
884 clear();
885 }
886
887 bool empty() const {
888 return data_ == NULL;
889 }
890
891 void open(const char *path, int oflag, int pflag, int mflag) {
892 clear();
893
894 file_.open(path, oflag);
895 int file(file_.file());
896
897 struct stat stat;
898 _syscall(fstat(file, &stat));
899 size_ = stat.st_size;
900
901 _syscall(data_ = mmap(NULL, size_, pflag, mflag, file, 0));
902 }
903
904 void open(const char *path, bool edit) {
905 if (edit)
906 open(path, O_RDWR, PROT_READ | PROT_WRITE, MAP_SHARED);
907 else
908 open(path, O_RDONLY, PROT_READ, MAP_PRIVATE);
909 }
910
911 void *data() const {
912 return data_;
913 }
914
915 size_t size() const {
916 return size_;
917 }
918
919 operator std::string() const {
920 return std::string(static_cast<char *>(data_), size_);
921 }
922 };
923
924 // I wish Apple cared about providing quality toolchains :/
925
926 template <typename Function_>
927 class Functor;
928
929 template <typename Type_, typename... Args_>
930 class Functor<Type_ (Args_...)> {
931 public:
932 virtual Type_ operator ()(Args_... args) const = 0;
933 };
934
935 template <typename Function_>
936 class FunctorImpl;
937
938 template <typename Value_, typename Type_, typename... Args_>
939 class FunctorImpl<Type_ (Value_::*)(Args_...) const> :
940 public Functor<Type_ (Args_...)>
941 {
942 private:
943 const Value_ *value_;
944
945 public:
946 FunctorImpl(const Value_ &value) :
947 value_(&value)
948 {
949 }
950
951 virtual Type_ operator ()(Args_... args) const {
952 return (*value_)(args...);
953 }
954 };
955
956 template <typename Function_>
957 FunctorImpl<decltype(&Function_::operator())> fun(const Function_ &value) {
958 return value;
959 }
960
961 static void resign(void *idata, size_t isize, std::streambuf &output, const Functor<size_t (size_t)> &allocate, const Functor<size_t (std::streambuf &output, size_t, const std::string &, const char *)> &save) {
962 FatHeader source(idata, isize);
963
964 size_t offset(0);
965 if (source.IsFat())
966 offset += sizeof(fat_header) + sizeof(fat_arch) * source.Swap(source->nfat_arch);
967
968 std::vector<CodesignAllocation> allocations;
969 _foreach (mach_header, source.GetMachHeaders()) {
970 struct linkedit_data_command *signature(NULL);
971 struct symtab_command *symtab(NULL);
972
973 _foreach (load_command, mach_header.GetLoadCommands()) {
974 uint32_t cmd(mach_header.Swap(load_command->cmd));
975 if (false);
976 else if (cmd == LC_CODE_SIGNATURE)
977 signature = reinterpret_cast<struct linkedit_data_command *>(load_command);
978 else if (cmd == LC_SYMTAB)
979 symtab = reinterpret_cast<struct symtab_command *>(load_command);
980 }
981
982 size_t size;
983 if (signature == NULL)
984 size = mach_header.GetSize();
985 else {
986 size = mach_header.Swap(signature->dataoff);
987 _assert(size <= mach_header.GetSize());
988 }
989
990 if (symtab != NULL) {
991 auto end(mach_header.Swap(symtab->stroff) + mach_header.Swap(symtab->strsize));
992 _assert(end <= size);
993 _assert(end >= size - 0x10);
994 size = end;
995 }
996
997 size_t alloc(allocate(size));
998
999 auto *fat_arch(mach_header.GetFatArch());
1000 uint32_t align(fat_arch == NULL ? 0 : source.Swap(fat_arch->align));
1001 offset = Align(offset, 1 << align);
1002
1003 uint32_t limit(size);
1004 if (alloc != 0)
1005 limit = Align(limit, 0x10);
1006
1007 allocations.push_back(CodesignAllocation(mach_header, offset, size, limit, alloc, align));
1008 offset += size + alloc;
1009 offset = Align(offset, 0x10);
1010 }
1011
1012 size_t position(0);
1013
1014 if (source.IsFat()) {
1015 fat_header fat_header;
1016 fat_header.magic = Swap(FAT_MAGIC);
1017 fat_header.nfat_arch = Swap(uint32_t(allocations.size()));
1018 put(output, &fat_header, sizeof(fat_header));
1019 position += sizeof(fat_header);
1020
1021 _foreach (allocation, allocations) {
1022 auto &mach_header(allocation.mach_header_);
1023
1024 fat_arch fat_arch;
1025 fat_arch.cputype = Swap(mach_header->cputype);
1026 fat_arch.cpusubtype = Swap(mach_header->cpusubtype);
1027 fat_arch.offset = Swap(allocation.offset_);
1028 fat_arch.size = Swap(allocation.limit_ + allocation.alloc_);
1029 fat_arch.align = Swap(allocation.align_);
1030 put(output, &fat_arch, sizeof(fat_arch));
1031 position += sizeof(fat_arch);
1032 }
1033 }
1034
1035 _foreach (allocation, allocations) {
1036 auto &mach_header(allocation.mach_header_);
1037
1038 pad(output, allocation.offset_ - position);
1039 position = allocation.offset_;
1040
1041 std::vector<std::string> commands;
1042
1043 _foreach (load_command, mach_header.GetLoadCommands()) {
1044 std::string copy(reinterpret_cast<const char *>(load_command), load_command->cmdsize);
1045
1046 switch (mach_header.Swap(load_command->cmd)) {
1047 case LC_CODE_SIGNATURE:
1048 continue;
1049 break;
1050
1051 case LC_SEGMENT: {
1052 auto segment_command(reinterpret_cast<struct segment_command *>(&copy[0]));
1053 if (strncmp(segment_command->segname, "__LINKEDIT", 16) != 0)
1054 break;
1055 size_t size(mach_header.Swap(allocation.limit_ + allocation.alloc_ - mach_header.Swap(segment_command->fileoff)));
1056 segment_command->filesize = size;
1057 segment_command->vmsize = Align(size, PageSize_);
1058 } break;
1059
1060 case LC_SEGMENT_64: {
1061 auto segment_command(reinterpret_cast<struct segment_command_64 *>(&copy[0]));
1062 if (strncmp(segment_command->segname, "__LINKEDIT", 16) != 0)
1063 break;
1064 size_t size(mach_header.Swap(allocation.limit_ + allocation.alloc_ - mach_header.Swap(segment_command->fileoff)));
1065 segment_command->filesize = size;
1066 segment_command->vmsize = Align(size, PageSize_);
1067 } break;
1068 }
1069
1070 commands.push_back(copy);
1071 }
1072
1073 if (allocation.alloc_ != 0) {
1074 linkedit_data_command signature;
1075 signature.cmd = mach_header.Swap(LC_CODE_SIGNATURE);
1076 signature.cmdsize = mach_header.Swap(uint32_t(sizeof(signature)));
1077 signature.dataoff = mach_header.Swap(allocation.limit_);
1078 signature.datasize = mach_header.Swap(allocation.alloc_);
1079 commands.push_back(std::string(reinterpret_cast<const char *>(&signature), sizeof(signature)));
1080 }
1081
1082 size_t begin(position);
1083
1084 uint32_t after(0);
1085 _foreach(command, commands)
1086 after += command.size();
1087
1088 std::stringbuf altern;
1089
1090 struct mach_header header(*mach_header);
1091 header.ncmds = mach_header.Swap(uint32_t(commands.size()));
1092 header.sizeofcmds = mach_header.Swap(after);
1093 put(output, &header, sizeof(header));
1094 put(altern, &header, sizeof(header));
1095 position += sizeof(header);
1096
1097 if (mach_header.Bits64()) {
1098 auto pad(mach_header.Swap(uint32_t(0)));
1099 put(output, &pad, sizeof(pad));
1100 put(altern, &pad, sizeof(pad));
1101 position += sizeof(pad);
1102 }
1103
1104 _foreach(command, commands) {
1105 put(output, command.data(), command.size());
1106 put(altern, command.data(), command.size());
1107 position += command.size();
1108 }
1109
1110 uint32_t before(mach_header.Swap(mach_header->sizeofcmds));
1111 if (before > after) {
1112 pad(output, before - after);
1113 pad(altern, before - after);
1114 position += before - after;
1115 }
1116
1117 auto top(reinterpret_cast<char *>(mach_header.GetBase()));
1118
1119 std::string overlap(altern.str());
1120 overlap.append(top + overlap.size(), Align(overlap.size(), 0x1000) - overlap.size());
1121
1122 put(output, top + (position - begin), allocation.size_ - (position - begin));
1123 position = begin + allocation.size_;
1124
1125 pad(output, allocation.limit_ - allocation.size_);
1126 position += allocation.limit_ - allocation.size_;
1127
1128 size_t saved(save(output, allocation.limit_, overlap, top));
1129 if (allocation.alloc_ > saved)
1130 pad(output, allocation.alloc_ - saved);
1131 position += allocation.alloc_;
1132 }
1133 }
1134
1135 typedef std::map<uint32_t, std::string> Blobs;
1136
1137 static void insert(Blobs &blobs, uint32_t slot, const std::stringbuf &buffer) {
1138 auto value(buffer.str());
1139 std::swap(blobs[slot], value);
1140 }
1141
1142 static void insert(Blobs &blobs, uint32_t slot, uint32_t magic, const std::stringbuf &buffer) {
1143 auto value(buffer.str());
1144 Blob blob;
1145 blob.magic = Swap(magic);
1146 blob.length = Swap(uint32_t(sizeof(blob) + value.size()));
1147 value.insert(0, reinterpret_cast<char *>(&blob), sizeof(blob));
1148 std::swap(blobs[slot], value);
1149 }
1150
1151 static size_t put(std::streambuf &output, uint32_t magic, const Blobs &blobs) {
1152 size_t total(0);
1153 _foreach (blob, blobs)
1154 total += blob.second.size();
1155
1156 struct SuperBlob super;
1157 super.blob.magic = Swap(magic);
1158 super.blob.length = Swap(uint32_t(sizeof(SuperBlob) + blobs.size() * sizeof(BlobIndex) + total));
1159 super.count = Swap(uint32_t(blobs.size()));
1160 put(output, &super, sizeof(super));
1161
1162 size_t offset(sizeof(SuperBlob) + sizeof(BlobIndex) * blobs.size());
1163
1164 _foreach (blob, blobs) {
1165 BlobIndex index;
1166 index.type = Swap(blob.first);
1167 index.offset = Swap(uint32_t(offset));
1168 put(output, &index, sizeof(index));
1169 offset += blob.second.size();
1170 }
1171
1172 _foreach (blob, blobs)
1173 put(output, blob.second.data(), blob.second.size());
1174
1175 return offset;
1176 }
1177
1178 class Buffer {
1179 private:
1180 BIO *bio_;
1181
1182 public:
1183 Buffer(BIO *bio) :
1184 bio_(bio)
1185 {
1186 _assert(bio_ != NULL);
1187 }
1188
1189 Buffer() :
1190 bio_(BIO_new(BIO_s_mem()))
1191 {
1192 }
1193
1194 Buffer(const char *data, size_t size) :
1195 Buffer(BIO_new_mem_buf(const_cast<char *>(data), size))
1196 {
1197 }
1198
1199 Buffer(const std::string &data) :
1200 Buffer(data.data(), data.size())
1201 {
1202 }
1203
1204 Buffer(PKCS7 *pkcs) :
1205 Buffer()
1206 {
1207 _assert(i2d_PKCS7_bio(bio_, pkcs) != 0);
1208 }
1209
1210 ~Buffer() {
1211 BIO_free_all(bio_);
1212 }
1213
1214 operator BIO *() const {
1215 return bio_;
1216 }
1217
1218 explicit operator std::string() const {
1219 char *data;
1220 auto size(BIO_get_mem_data(bio_, &data));
1221 return std::string(data, size);
1222 }
1223 };
1224
1225 class Stuff {
1226 private:
1227 PKCS12 *value_;
1228 EVP_PKEY *key_;
1229 X509 *cert_;
1230 STACK_OF(X509) *ca_;
1231
1232 public:
1233 Stuff(BIO *bio) :
1234 value_(d2i_PKCS12_bio(bio, NULL)),
1235 ca_(NULL)
1236 {
1237 _assert(value_ != NULL);
1238 _assert(PKCS12_parse(value_, "", &key_, &cert_, &ca_) != 0);
1239 _assert(key_ != NULL);
1240 _assert(cert_ != NULL);
1241 }
1242
1243 Stuff(const std::string &data) :
1244 Stuff(Buffer(data))
1245 {
1246 }
1247
1248 ~Stuff() {
1249 sk_X509_pop_free(ca_, X509_free);
1250 X509_free(cert_);
1251 EVP_PKEY_free(key_);
1252 PKCS12_free(value_);
1253 }
1254
1255 operator PKCS12 *() const {
1256 return value_;
1257 }
1258
1259 operator EVP_PKEY *() const {
1260 return key_;
1261 }
1262
1263 operator X509 *() const {
1264 return cert_;
1265 }
1266
1267 operator STACK_OF(X509) *() const {
1268 return ca_;
1269 }
1270 };
1271
1272 class Signature {
1273 private:
1274 PKCS7 *value_;
1275
1276 public:
1277 Signature(const Stuff &stuff, const Buffer &data) :
1278 value_(PKCS7_sign(stuff, stuff, stuff, data, PKCS7_BINARY | PKCS7_DETACHED))
1279 {
1280 _assert(value_ != NULL);
1281 }
1282
1283 ~Signature() {
1284 PKCS7_free(value_);
1285 }
1286
1287 operator PKCS7 *() const {
1288 return value_;
1289 }
1290 };
1291
1292 typedef std::map<uint32_t, std::string> Slots;
1293
1294 void resign(void *idata, size_t isize, std::streambuf &output, const std::string &name, const std::string &entitlements, const std::string &key, const Slots &slots) {
1295 resign(idata, isize, output, fun([&](size_t size) -> size_t {
1296 size_t alloc(sizeof(struct SuperBlob));
1297
1298 uint32_t special(0);
1299
1300 special = std::max(special, CSSLOT_REQUIREMENTS);
1301 alloc += sizeof(struct BlobIndex);
1302 alloc += 0xc;
1303
1304 if (!entitlements.empty()) {
1305 special = std::max(special, CSSLOT_ENTITLEMENTS);
1306 alloc += sizeof(struct BlobIndex);
1307 alloc += sizeof(struct Blob);
1308 alloc += entitlements.size();
1309 }
1310
1311 special = std::max(special, CSSLOT_CODEDIRECTORY);
1312 alloc += sizeof(struct BlobIndex);
1313 alloc += sizeof(struct Blob);
1314 alloc += sizeof(struct CodeDirectory);
1315 alloc += name.size() + 1;
1316
1317 if (!key.empty()) {
1318 alloc += sizeof(struct BlobIndex);
1319 alloc += sizeof(struct Blob);
1320 // XXX: this is just a "sufficiently large number"
1321 alloc += 0x3000;
1322 }
1323
1324 _foreach (slot, slots)
1325 special = std::max(special, slot.first);
1326
1327 uint32_t normal((size + PageSize_ - 1) / PageSize_);
1328 alloc = Align(alloc + (special + normal) * SHA_DIGEST_LENGTH, 16);
1329 return alloc;
1330 }), fun([&](std::streambuf &output, size_t limit, const std::string &overlap, const char *top) -> size_t {
1331 Blobs blobs;
1332
1333 if (true) {
1334 std::stringbuf data;
1335
1336 Blobs requirements;
1337 put(data, CSMAGIC_REQUIREMENTS, requirements);
1338
1339 insert(blobs, CSSLOT_REQUIREMENTS, data);
1340 }
1341
1342 if (!entitlements.empty()) {
1343 std::stringbuf data;
1344 put(data, entitlements.data(), entitlements.size());
1345 insert(blobs, CSSLOT_ENTITLEMENTS, CSMAGIC_EMBEDDED_ENTITLEMENTS, data);
1346 }
1347
1348 if (true) {
1349 std::stringbuf data;
1350
1351 uint32_t special(0);
1352 _foreach (blob, blobs)
1353 special = std::max(special, blob.first);
1354 _foreach (slot, slots)
1355 special = std::max(special, slot.first);
1356 uint32_t normal((limit + PageSize_ - 1) / PageSize_);
1357
1358 CodeDirectory directory;
1359 directory.version = Swap(uint32_t(0x00020001));
1360 directory.flags = Swap(uint32_t(0));
1361 directory.hashOffset = Swap(uint32_t(sizeof(Blob) + sizeof(CodeDirectory) + name.size() + 1 + SHA_DIGEST_LENGTH * special));
1362 directory.identOffset = Swap(uint32_t(sizeof(Blob) + sizeof(CodeDirectory)));
1363 directory.nSpecialSlots = Swap(special);
1364 directory.codeLimit = Swap(uint32_t(limit));
1365 directory.nCodeSlots = Swap(normal);
1366 directory.hashSize = SHA_DIGEST_LENGTH;
1367 directory.hashType = CS_HASHTYPE_SHA1;
1368 directory.spare1 = 0x00;
1369 directory.pageSize = PageShift_;
1370 directory.spare2 = Swap(uint32_t(0));
1371 put(data, &directory, sizeof(directory));
1372
1373 put(data, name.c_str(), name.size() + 1);
1374
1375 uint8_t storage[special + normal][SHA_DIGEST_LENGTH];
1376 uint8_t (*hashes)[SHA_DIGEST_LENGTH] = storage + special;
1377
1378 memset(storage, 0, sizeof(*storage) * special);
1379
1380 _foreach (blob, blobs) {
1381 auto local(reinterpret_cast<const Blob *>(&blob.second[0]));
1382 sha1((uint8_t *) (hashes - blob.first), local, Swap(local->length));
1383 }
1384
1385 _foreach (slot, slots) {
1386 _assert(sizeof(*hashes) == slot.second.size());
1387 memcpy(hashes - slot.first, slot.second.data(), slot.second.size());
1388 }
1389
1390 if (normal != 1)
1391 for (size_t i = 0; i != normal - 1; ++i)
1392 sha1(hashes[i], (PageSize_ * i < overlap.size() ? overlap.data() : top) + PageSize_ * i, PageSize_);
1393 if (normal != 0)
1394 sha1(hashes[normal - 1], top + PageSize_ * (normal - 1), ((limit - 1) % PageSize_) + 1);
1395
1396 put(data, storage, sizeof(storage));
1397
1398 insert(blobs, CSSLOT_CODEDIRECTORY, CSMAGIC_CODEDIRECTORY, data);
1399 }
1400
1401 if (!key.empty()) {
1402 std::stringbuf data;
1403 const std::string &sign(blobs[CSSLOT_CODEDIRECTORY]);
1404
1405 Stuff stuff(key);
1406 Buffer bio(sign);
1407
1408 Signature signature(stuff, sign);
1409 Buffer result(signature);
1410 std::string value(result);
1411 put(data, value.data(), value.size());
1412
1413 insert(blobs, CSSLOT_SIGNATURESLOT, CSMAGIC_BLOBWRAPPER, data);
1414 }
1415
1416 return put(output, CSMAGIC_EMBEDDED_SIGNATURE, blobs);
1417 }));
1418 }
1419
1420 static void resign(void *idata, size_t isize, std::streambuf &output) {
1421 resign(idata, isize, output, fun([](size_t size) -> size_t {
1422 return 0;
1423 }), fun([](std::streambuf &output, size_t limit, const std::string &overlap, const char *top) -> size_t {
1424 return 0;
1425 }));
1426 }
1427
1428 int main(int argc, char *argv[]) {
1429 OpenSSL_add_all_algorithms();
1430
1431 union {
1432 uint16_t word;
1433 uint8_t byte[2];
1434 } endian = {1};
1435
1436 little_ = endian.byte[0];
1437
1438 bool flag_r(false);
1439 bool flag_e(false);
1440
1441 bool flag_T(false);
1442
1443 bool flag_S(false);
1444 bool flag_s(false);
1445
1446 bool flag_D(false);
1447
1448 bool flag_A(false);
1449 bool flag_a(false);
1450
1451 uint32_t flag_CPUType(_not(uint32_t));
1452 uint32_t flag_CPUSubtype(_not(uint32_t));
1453
1454 const char *flag_I(NULL);
1455
1456 bool timeh(false);
1457 uint32_t timev(0);
1458
1459 Map entitlements;
1460 Map key;
1461 Slots slots;
1462
1463 std::vector<std::string> files;
1464
1465 if (argc == 1) {
1466 fprintf(stderr, "usage: %s -S[entitlements.xml] <binary>\n", argv[0]);
1467 fprintf(stderr, " %s -e MobileSafari\n", argv[0]);
1468 fprintf(stderr, " %s -S cat\n", argv[0]);
1469 fprintf(stderr, " %s -Stfp.xml gdb\n", argv[0]);
1470 exit(0);
1471 }
1472
1473 for (int argi(1); argi != argc; ++argi)
1474 if (argv[argi][0] != '-')
1475 files.push_back(argv[argi]);
1476 else switch (argv[argi][1]) {
1477 case 'r':
1478 _assert(!flag_s);
1479 _assert(!flag_S);
1480 flag_r = true;
1481 break;
1482
1483 case 'e': flag_e = true; break;
1484
1485 case 'E': {
1486 const char *slot = argv[argi] + 2;
1487 const char *colon = strchr(slot, ':');
1488 _assert(colon != NULL);
1489 Map file(colon + 1, O_RDONLY, PROT_READ, MAP_PRIVATE);
1490 char *arge;
1491 unsigned number(strtoul(slot, &arge, 0));
1492 _assert(arge == colon);
1493 std::string &hash(slots[number]);
1494 hash.resize(SHA_DIGEST_LENGTH);
1495 sha1(reinterpret_cast<uint8_t *>(&hash[0]), file.data(), file.size());
1496 } break;
1497
1498 case 'D': flag_D = true; break;
1499
1500 case 'a': flag_a = true; break;
1501
1502 case 'A':
1503 _assert(!flag_A);
1504 flag_A = true;
1505 if (argv[argi][2] != '\0') {
1506 const char *cpu = argv[argi] + 2;
1507 const char *colon = strchr(cpu, ':');
1508 _assert(colon != NULL);
1509 char *arge;
1510 flag_CPUType = strtoul(cpu, &arge, 0);
1511 _assert(arge == colon);
1512 flag_CPUSubtype = strtoul(colon + 1, &arge, 0);
1513 _assert(arge == argv[argi] + strlen(argv[argi]));
1514 }
1515 break;
1516
1517 case 's':
1518 _assert(!flag_r);
1519 _assert(!flag_S);
1520 flag_s = true;
1521 break;
1522
1523 case 'S':
1524 _assert(!flag_r);
1525 _assert(!flag_s);
1526 flag_S = true;
1527 if (argv[argi][2] != '\0') {
1528 const char *xml = argv[argi] + 2;
1529 entitlements.open(xml, O_RDONLY, PROT_READ, MAP_PRIVATE);
1530 }
1531 break;
1532
1533 case 'K':
1534 key.open(argv[argi] + 2, O_RDONLY, PROT_READ, MAP_PRIVATE);
1535 break;
1536
1537 case 'T': {
1538 flag_T = true;
1539 if (argv[argi][2] == '-')
1540 timeh = true;
1541 else {
1542 char *arge;
1543 timev = strtoul(argv[argi] + 2, &arge, 0);
1544 _assert(arge == argv[argi] + strlen(argv[argi]));
1545 }
1546 } break;
1547
1548 case 'I': {
1549 flag_I = argv[argi] + 2;
1550 } break;
1551
1552 default:
1553 goto usage;
1554 break;
1555 }
1556
1557 _assert(flag_S || key.empty());
1558 _assert(flag_S || flag_I == NULL);
1559
1560 if (files.empty()) usage: {
1561 exit(0);
1562 }
1563
1564 size_t filei(0), filee(0);
1565 _foreach (file, files) try {
1566 const char *path(file.c_str());
1567
1568 if (flag_S || flag_r) {
1569 Map input(path, O_RDONLY, PROT_READ, MAP_PRIVATE);
1570
1571 std::string dir;
1572 const char *base = strrchr(path, '/');
1573
1574 if (base != NULL)
1575 dir.assign(path, base++ - path + 1);
1576 else
1577 base = path;
1578
1579 std::string temp(dir + "." + base + ".cs");
1580 std::filebuf output;
1581 _assert(output.open(temp.c_str(), std::ios::out | std::ios::trunc | std::ios::binary) == &output);
1582
1583 if (flag_r)
1584 resign(input.data(), input.size(), output);
1585 else {
1586 const char *name(flag_I ?: base);
1587 resign(input.data(), input.size(), output, name, entitlements, key, slots);
1588 }
1589
1590 struct stat info;
1591 _syscall(stat(path, &info));
1592 #ifndef __WIN32__
1593 _syscall(chown(temp.c_str(), info.st_uid, info.st_gid));
1594 #endif
1595 _syscall(chmod(temp.c_str(), info.st_mode));
1596 _syscall(unlink(path));
1597 _syscall(rename(temp.c_str(), path));
1598 }
1599
1600 Map mapping(path, flag_T || flag_s);
1601 FatHeader fat_header(mapping.data(), mapping.size());
1602
1603 _foreach (mach_header, fat_header.GetMachHeaders()) {
1604 struct linkedit_data_command *signature(NULL);
1605 struct encryption_info_command *encryption(NULL);
1606
1607 if (flag_A) {
1608 if (mach_header.GetCPUType() != flag_CPUType)
1609 continue;
1610 if (mach_header.GetCPUSubtype() != flag_CPUSubtype)
1611 continue;
1612 }
1613
1614 if (flag_a)
1615 printf("cpu=0x%x:0x%x\n", mach_header.GetCPUType(), mach_header.GetCPUSubtype());
1616
1617 _foreach (load_command, mach_header.GetLoadCommands()) {
1618 uint32_t cmd(mach_header.Swap(load_command->cmd));
1619
1620 if (false);
1621 else if (cmd == LC_CODE_SIGNATURE)
1622 signature = reinterpret_cast<struct linkedit_data_command *>(load_command);
1623 else if (cmd == LC_ENCRYPTION_INFO || cmd == LC_ENCRYPTION_INFO_64)
1624 encryption = reinterpret_cast<struct encryption_info_command *>(load_command);
1625 else if (cmd == LC_ID_DYLIB) {
1626 volatile struct dylib_command *dylib_command(reinterpret_cast<struct dylib_command *>(load_command));
1627
1628 if (flag_T) {
1629 uint32_t timed;
1630
1631 if (!timeh)
1632 timed = timev;
1633 else {
1634 dylib_command->dylib.timestamp = 0;
1635 timed = hash(reinterpret_cast<uint8_t *>(mach_header.GetBase()), mach_header.GetSize(), timev);
1636 }
1637
1638 dylib_command->dylib.timestamp = mach_header.Swap(timed);
1639 }
1640 }
1641 }
1642
1643 if (flag_D) {
1644 _assert(encryption != NULL);
1645 encryption->cryptid = mach_header.Swap(0);
1646 }
1647
1648 if (flag_e) {
1649 _assert(signature != NULL);
1650
1651 uint32_t data = mach_header.Swap(signature->dataoff);
1652
1653 uint8_t *top = reinterpret_cast<uint8_t *>(mach_header.GetBase());
1654 uint8_t *blob = top + data;
1655 struct SuperBlob *super = reinterpret_cast<struct SuperBlob *>(blob);
1656
1657 for (size_t index(0); index != Swap(super->count); ++index)
1658 if (Swap(super->index[index].type) == CSSLOT_ENTITLEMENTS) {
1659 uint32_t begin = Swap(super->index[index].offset);
1660 struct Blob *entitlements = reinterpret_cast<struct Blob *>(blob + begin);
1661 fwrite(entitlements + 1, 1, Swap(entitlements->length) - sizeof(*entitlements), stdout);
1662 }
1663 }
1664
1665 if (flag_s) {
1666 _assert(signature != NULL);
1667
1668 uint32_t data = mach_header.Swap(signature->dataoff);
1669
1670 uint8_t *top = reinterpret_cast<uint8_t *>(mach_header.GetBase());
1671 uint8_t *blob = top + data;
1672 struct SuperBlob *super = reinterpret_cast<struct SuperBlob *>(blob);
1673
1674 for (size_t index(0); index != Swap(super->count); ++index)
1675 if (Swap(super->index[index].type) == CSSLOT_CODEDIRECTORY) {
1676 uint32_t begin = Swap(super->index[index].offset);
1677 struct CodeDirectory *directory = reinterpret_cast<struct CodeDirectory *>(blob + begin);
1678
1679 uint8_t (*hashes)[SHA_DIGEST_LENGTH] = reinterpret_cast<uint8_t (*)[SHA_DIGEST_LENGTH]>(blob + begin + Swap(directory->hashOffset));
1680 uint32_t pages = Swap(directory->nCodeSlots);
1681
1682 if (pages != 1)
1683 for (size_t i = 0; i != pages - 1; ++i)
1684 sha1(hashes[i], top + PageSize_ * i, PageSize_);
1685 if (pages != 0)
1686 sha1(hashes[pages - 1], top + PageSize_ * (pages - 1), ((data - 1) % PageSize_) + 1);
1687 }
1688 }
1689 }
1690
1691 ++filei;
1692 } catch (const char *) {
1693 ++filee;
1694 ++filei;
1695 }
1696
1697 return filee;
1698 }
Link Identity Editor