]> git.saurik.com Git - ldid.git/blob - ldid.cpp
projects / ldid.git / blob
? search:


a6b86d2c7ff735350468503ec08835b3fb2c7ade
[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() :
947 value_(NULL)
948 {
949 }
950
951 FunctorImpl(const Value_ &value) :
952 value_(&value)
953 {
954 }
955
956 virtual Type_ operator ()(Args_... args) const {
957 return (*value_)(args...);
958 }
959 };
960
961 template <typename Function_>
962 FunctorImpl<decltype(&Function_::operator())> fun(const Function_ &value) {
963 return value;
964 }
965
966 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) {
967 FatHeader source(idata, isize);
968
969 size_t offset(0);
970 if (source.IsFat())
971 offset += sizeof(fat_header) + sizeof(fat_arch) * source.Swap(source->nfat_arch);
972
973 std::vector<CodesignAllocation> allocations;
974 _foreach (mach_header, source.GetMachHeaders()) {
975 struct linkedit_data_command *signature(NULL);
976 struct symtab_command *symtab(NULL);
977
978 _foreach (load_command, mach_header.GetLoadCommands()) {
979 uint32_t cmd(mach_header.Swap(load_command->cmd));
980 if (false);
981 else if (cmd == LC_CODE_SIGNATURE)
982 signature = reinterpret_cast<struct linkedit_data_command *>(load_command);
983 else if (cmd == LC_SYMTAB)
984 symtab = reinterpret_cast<struct symtab_command *>(load_command);
985 }
986
987 size_t size;
988 if (signature == NULL)
989 size = mach_header.GetSize();
990 else {
991 size = mach_header.Swap(signature->dataoff);
992 _assert(size <= mach_header.GetSize());
993 }
994
995 if (symtab != NULL) {
996 auto end(mach_header.Swap(symtab->stroff) + mach_header.Swap(symtab->strsize));
997 _assert(end <= size);
998 _assert(end >= size - 0x10);
999 size = end;
1000 }
1001
1002 size_t alloc(allocate(size));
1003
1004 auto *fat_arch(mach_header.GetFatArch());
1005 uint32_t align(fat_arch == NULL ? 0 : source.Swap(fat_arch->align));
1006 offset = Align(offset, 1 << align);
1007
1008 uint32_t limit(size);
1009 if (alloc != 0)
1010 limit = Align(limit, 0x10);
1011
1012 allocations.push_back(CodesignAllocation(mach_header, offset, size, limit, alloc, align));
1013 offset += size + alloc;
1014 offset = Align(offset, 0x10);
1015 }
1016
1017 size_t position(0);
1018
1019 if (source.IsFat()) {
1020 fat_header fat_header;
1021 fat_header.magic = Swap(FAT_MAGIC);
1022 fat_header.nfat_arch = Swap(uint32_t(allocations.size()));
1023 put(output, &fat_header, sizeof(fat_header));
1024 position += sizeof(fat_header);
1025
1026 _foreach (allocation, allocations) {
1027 auto &mach_header(allocation.mach_header_);
1028
1029 fat_arch fat_arch;
1030 fat_arch.cputype = Swap(mach_header->cputype);
1031 fat_arch.cpusubtype = Swap(mach_header->cpusubtype);
1032 fat_arch.offset = Swap(allocation.offset_);
1033 fat_arch.size = Swap(allocation.limit_ + allocation.alloc_);
1034 fat_arch.align = Swap(allocation.align_);
1035 put(output, &fat_arch, sizeof(fat_arch));
1036 position += sizeof(fat_arch);
1037 }
1038 }
1039
1040 _foreach (allocation, allocations) {
1041 auto &mach_header(allocation.mach_header_);
1042
1043 pad(output, allocation.offset_ - position);
1044 position = allocation.offset_;
1045
1046 std::vector<std::string> commands;
1047
1048 _foreach (load_command, mach_header.GetLoadCommands()) {
1049 std::string copy(reinterpret_cast<const char *>(load_command), load_command->cmdsize);
1050
1051 switch (mach_header.Swap(load_command->cmd)) {
1052 case LC_CODE_SIGNATURE:
1053 continue;
1054 break;
1055
1056 case LC_SEGMENT: {
1057 auto segment_command(reinterpret_cast<struct segment_command *>(&copy[0]));
1058 if (strncmp(segment_command->segname, "__LINKEDIT", 16) != 0)
1059 break;
1060 size_t size(mach_header.Swap(allocation.limit_ + allocation.alloc_ - mach_header.Swap(segment_command->fileoff)));
1061 segment_command->filesize = size;
1062 segment_command->vmsize = Align(size, PageSize_);
1063 } break;
1064
1065 case LC_SEGMENT_64: {
1066 auto segment_command(reinterpret_cast<struct segment_command_64 *>(&copy[0]));
1067 if (strncmp(segment_command->segname, "__LINKEDIT", 16) != 0)
1068 break;
1069 size_t size(mach_header.Swap(allocation.limit_ + allocation.alloc_ - mach_header.Swap(segment_command->fileoff)));
1070 segment_command->filesize = size;
1071 segment_command->vmsize = Align(size, PageSize_);
1072 } break;
1073 }
1074
1075 commands.push_back(copy);
1076 }
1077
1078 if (allocation.alloc_ != 0) {
1079 linkedit_data_command signature;
1080 signature.cmd = mach_header.Swap(LC_CODE_SIGNATURE);
1081 signature.cmdsize = mach_header.Swap(uint32_t(sizeof(signature)));
1082 signature.dataoff = mach_header.Swap(allocation.limit_);
1083 signature.datasize = mach_header.Swap(allocation.alloc_);
1084 commands.push_back(std::string(reinterpret_cast<const char *>(&signature), sizeof(signature)));
1085 }
1086
1087 size_t begin(position);
1088
1089 uint32_t after(0);
1090 _foreach(command, commands)
1091 after += command.size();
1092
1093 std::stringbuf altern;
1094
1095 struct mach_header header(*mach_header);
1096 header.ncmds = mach_header.Swap(uint32_t(commands.size()));
1097 header.sizeofcmds = mach_header.Swap(after);
1098 put(output, &header, sizeof(header));
1099 put(altern, &header, sizeof(header));
1100 position += sizeof(header);
1101
1102 if (mach_header.Bits64()) {
1103 auto pad(mach_header.Swap(uint32_t(0)));
1104 put(output, &pad, sizeof(pad));
1105 put(altern, &pad, sizeof(pad));
1106 position += sizeof(pad);
1107 }
1108
1109 _foreach(command, commands) {
1110 put(output, command.data(), command.size());
1111 put(altern, command.data(), command.size());
1112 position += command.size();
1113 }
1114
1115 uint32_t before(mach_header.Swap(mach_header->sizeofcmds));
1116 if (before > after) {
1117 pad(output, before - after);
1118 pad(altern, before - after);
1119 position += before - after;
1120 }
1121
1122 auto top(reinterpret_cast<char *>(mach_header.GetBase()));
1123
1124 std::string overlap(altern.str());
1125 overlap.append(top + overlap.size(), Align(overlap.size(), 0x1000) - overlap.size());
1126
1127 put(output, top + (position - begin), allocation.size_ - (position - begin));
1128 position = begin + allocation.size_;
1129
1130 pad(output, allocation.limit_ - allocation.size_);
1131 position += allocation.limit_ - allocation.size_;
1132
1133 size_t saved(save(output, allocation.limit_, overlap, top));
1134 if (allocation.alloc_ > saved)
1135 pad(output, allocation.alloc_ - saved);
1136 position += allocation.alloc_;
1137 }
1138 }
1139
1140 typedef std::map<uint32_t, std::string> Blobs;
1141
1142 static void insert(Blobs &blobs, uint32_t slot, const std::stringbuf &buffer) {
1143 auto value(buffer.str());
1144 std::swap(blobs[slot], value);
1145 }
1146
1147 static void insert(Blobs &blobs, uint32_t slot, uint32_t magic, const std::stringbuf &buffer) {
1148 auto value(buffer.str());
1149 Blob blob;
1150 blob.magic = Swap(magic);
1151 blob.length = Swap(uint32_t(sizeof(blob) + value.size()));
1152 value.insert(0, reinterpret_cast<char *>(&blob), sizeof(blob));
1153 std::swap(blobs[slot], value);
1154 }
1155
1156 static size_t put(std::streambuf &output, uint32_t magic, const Blobs &blobs) {
1157 size_t total(0);
1158 _foreach (blob, blobs)
1159 total += blob.second.size();
1160
1161 struct SuperBlob super;
1162 super.blob.magic = Swap(magic);
1163 super.blob.length = Swap(uint32_t(sizeof(SuperBlob) + blobs.size() * sizeof(BlobIndex) + total));
1164 super.count = Swap(uint32_t(blobs.size()));
1165 put(output, &super, sizeof(super));
1166
1167 size_t offset(sizeof(SuperBlob) + sizeof(BlobIndex) * blobs.size());
1168
1169 _foreach (blob, blobs) {
1170 BlobIndex index;
1171 index.type = Swap(blob.first);
1172 index.offset = Swap(uint32_t(offset));
1173 put(output, &index, sizeof(index));
1174 offset += blob.second.size();
1175 }
1176
1177 _foreach (blob, blobs)
1178 put(output, blob.second.data(), blob.second.size());
1179
1180 return offset;
1181 }
1182
1183 class Buffer {
1184 private:
1185 BIO *bio_;
1186
1187 public:
1188 Buffer(BIO *bio) :
1189 bio_(bio)
1190 {
1191 _assert(bio_ != NULL);
1192 }
1193
1194 Buffer() :
1195 bio_(BIO_new(BIO_s_mem()))
1196 {
1197 }
1198
1199 Buffer(const char *data, size_t size) :
1200 Buffer(BIO_new_mem_buf(const_cast<char *>(data), size))
1201 {
1202 }
1203
1204 Buffer(const std::string &data) :
1205 Buffer(data.data(), data.size())
1206 {
1207 }
1208
1209 Buffer(PKCS7 *pkcs) :
1210 Buffer()
1211 {
1212 _assert(i2d_PKCS7_bio(bio_, pkcs) != 0);
1213 }
1214
1215 ~Buffer() {
1216 BIO_free_all(bio_);
1217 }
1218
1219 operator BIO *() const {
1220 return bio_;
1221 }
1222
1223 explicit operator std::string() const {
1224 char *data;
1225 auto size(BIO_get_mem_data(bio_, &data));
1226 return std::string(data, size);
1227 }
1228 };
1229
1230 class Stuff {
1231 private:
1232 PKCS12 *value_;
1233 EVP_PKEY *key_;
1234 X509 *cert_;
1235 STACK_OF(X509) *ca_;
1236
1237 public:
1238 Stuff(BIO *bio) :
1239 value_(d2i_PKCS12_bio(bio, NULL)),
1240 ca_(NULL)
1241 {
1242 _assert(value_ != NULL);
1243 _assert(PKCS12_parse(value_, "", &key_, &cert_, &ca_) != 0);
1244 _assert(key_ != NULL);
1245 _assert(cert_ != NULL);
1246 }
1247
1248 Stuff(const std::string &data) :
1249 Stuff(Buffer(data))
1250 {
1251 }
1252
1253 ~Stuff() {
1254 sk_X509_pop_free(ca_, X509_free);
1255 X509_free(cert_);
1256 EVP_PKEY_free(key_);
1257 PKCS12_free(value_);
1258 }
1259
1260 operator PKCS12 *() const {
1261 return value_;
1262 }
1263
1264 operator EVP_PKEY *() const {
1265 return key_;
1266 }
1267
1268 operator X509 *() const {
1269 return cert_;
1270 }
1271
1272 operator STACK_OF(X509) *() const {
1273 return ca_;
1274 }
1275 };
1276
1277 class Signature {
1278 private:
1279 PKCS7 *value_;
1280
1281 public:
1282 Signature(const Stuff &stuff, const Buffer &data) :
1283 value_(PKCS7_sign(stuff, stuff, stuff, data, PKCS7_BINARY | PKCS7_DETACHED))
1284 {
1285 _assert(value_ != NULL);
1286 }
1287
1288 ~Signature() {
1289 PKCS7_free(value_);
1290 }
1291
1292 operator PKCS7 *() const {
1293 return value_;
1294 }
1295 };
1296
1297 void resign(void *idata, size_t isize, std::streambuf &output, const std::string &name, const std::string &entitlements, const std::string &key) {
1298 resign(idata, isize, output, fun([&](size_t size) -> size_t {
1299 size_t alloc(sizeof(struct SuperBlob));
1300
1301 uint32_t special(0);
1302
1303 special = std::max(special, CSSLOT_REQUIREMENTS);
1304 alloc += sizeof(struct BlobIndex);
1305 alloc += 0xc;
1306
1307 if (!entitlements.empty()) {
1308 special = std::max(special, CSSLOT_ENTITLEMENTS);
1309 alloc += sizeof(struct BlobIndex);
1310 alloc += sizeof(struct Blob);
1311 alloc += entitlements.size();
1312 }
1313
1314 special = std::max(special, CSSLOT_CODEDIRECTORY);
1315 alloc += sizeof(struct BlobIndex);
1316 alloc += sizeof(struct Blob);
1317 alloc += sizeof(struct CodeDirectory);
1318 alloc += name.size() + 1;
1319
1320 if (!key.empty()) {
1321 alloc += sizeof(struct BlobIndex);
1322 alloc += sizeof(struct Blob);
1323 // XXX: this is just a "sufficiently large number"
1324 alloc += 0x3000;
1325 }
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 uint32_t normal((limit + PageSize_ - 1) / PageSize_);
1355
1356 CodeDirectory directory;
1357 directory.version = Swap(uint32_t(0x00020001));
1358 directory.flags = Swap(uint32_t(0));
1359 directory.hashOffset = Swap(uint32_t(sizeof(Blob) + sizeof(CodeDirectory) + name.size() + 1 + SHA_DIGEST_LENGTH * special));
1360 directory.identOffset = Swap(uint32_t(sizeof(Blob) + sizeof(CodeDirectory)));
1361 directory.nSpecialSlots = Swap(special);
1362 directory.codeLimit = Swap(uint32_t(limit));
1363 directory.nCodeSlots = Swap(normal);
1364 directory.hashSize = SHA_DIGEST_LENGTH;
1365 directory.hashType = CS_HASHTYPE_SHA1;
1366 directory.spare1 = 0x00;
1367 directory.pageSize = PageShift_;
1368 directory.spare2 = Swap(uint32_t(0));
1369 put(data, &directory, sizeof(directory));
1370
1371 put(data, name.c_str(), name.size() + 1);
1372
1373 uint8_t storage[special + normal][SHA_DIGEST_LENGTH];
1374 uint8_t (*hashes)[SHA_DIGEST_LENGTH] = storage + special;
1375
1376 memset(storage, 0, sizeof(*storage) * special);
1377
1378 _foreach (blob, blobs) {
1379 auto local(reinterpret_cast<const Blob *>(&blob.second[0]));
1380 sha1((uint8_t *) (hashes - blob.first), local, Swap(local->length));
1381 }
1382
1383 if (normal != 1)
1384 for (size_t i = 0; i != normal - 1; ++i)
1385 sha1(hashes[i], (PageSize_ * i < overlap.size() ? overlap.data() : top) + PageSize_ * i, PageSize_);
1386 if (normal != 0)
1387 sha1(hashes[normal - 1], top + PageSize_ * (normal - 1), ((limit - 1) % PageSize_) + 1);
1388
1389 put(data, storage, sizeof(storage));
1390
1391 insert(blobs, CSSLOT_CODEDIRECTORY, CSMAGIC_CODEDIRECTORY, data);
1392 }
1393
1394 if (!key.empty()) {
1395 std::stringbuf data;
1396 const std::string &sign(blobs[CSSLOT_CODEDIRECTORY]);
1397
1398 Stuff stuff(key);
1399 Buffer bio(sign);
1400
1401 Signature signature(stuff, sign);
1402 Buffer result(signature);
1403 std::string value(result);
1404 put(data, value.data(), value.size());
1405
1406 insert(blobs, CSSLOT_SIGNATURESLOT, CSMAGIC_BLOBWRAPPER, data);
1407 }
1408
1409 return put(output, CSMAGIC_EMBEDDED_SIGNATURE, blobs);
1410 }));
1411 }
1412
1413 static void resign(void *idata, size_t isize, std::streambuf &output) {
1414 resign(idata, isize, output, fun([](size_t size) -> size_t {
1415 return 0;
1416 }), fun([](std::streambuf &output, size_t limit, const std::string &overlap, const char *top) -> size_t {
1417 return 0;
1418 }));
1419 }
1420
1421 int main(int argc, char *argv[]) {
1422 OpenSSL_add_all_algorithms();
1423
1424 union {
1425 uint16_t word;
1426 uint8_t byte[2];
1427 } endian = {1};
1428
1429 little_ = endian.byte[0];
1430
1431 bool flag_r(false);
1432 bool flag_e(false);
1433
1434 bool flag_T(false);
1435
1436 bool flag_S(false);
1437 bool flag_s(false);
1438
1439 bool flag_D(false);
1440
1441 bool flag_A(false);
1442 bool flag_a(false);
1443
1444 uint32_t flag_CPUType(_not(uint32_t));
1445 uint32_t flag_CPUSubtype(_not(uint32_t));
1446
1447 const char *flag_I(NULL);
1448
1449 bool timeh(false);
1450 uint32_t timev(0);
1451
1452 Map entitlements;
1453 Map key;
1454
1455 std::vector<std::string> files;
1456
1457 if (argc == 1) {
1458 fprintf(stderr, "usage: %s -S[entitlements.xml] <binary>\n", argv[0]);
1459 fprintf(stderr, " %s -e MobileSafari\n", argv[0]);
1460 fprintf(stderr, " %s -S cat\n", argv[0]);
1461 fprintf(stderr, " %s -Stfp.xml gdb\n", argv[0]);
1462 exit(0);
1463 }
1464
1465 for (int argi(1); argi != argc; ++argi)
1466 if (argv[argi][0] != '-')
1467 files.push_back(argv[argi]);
1468 else switch (argv[argi][1]) {
1469 case 'r':
1470 _assert(!flag_s);
1471 _assert(!flag_S);
1472 flag_r = true;
1473 break;
1474
1475 case 'e': flag_e = true; break;
1476
1477 case 'D': flag_D = true; break;
1478
1479 case 'a': flag_a = true; break;
1480
1481 case 'A':
1482 _assert(!flag_A);
1483 flag_A = true;
1484 if (argv[argi][2] != '\0') {
1485 const char *cpu = argv[argi] + 2;
1486 const char *colon = strchr(cpu, ':');
1487 _assert(colon != NULL);
1488 char *arge;
1489 flag_CPUType = strtoul(cpu, &arge, 0);
1490 _assert(arge == colon);
1491 flag_CPUSubtype = strtoul(colon + 1, &arge, 0);
1492 _assert(arge == argv[argi] + strlen(argv[argi]));
1493 }
1494 break;
1495
1496 case 's':
1497 _assert(!flag_r);
1498 _assert(!flag_S);
1499 flag_s = true;
1500 break;
1501
1502 case 'S':
1503 _assert(!flag_r);
1504 _assert(!flag_s);
1505 flag_S = true;
1506 if (argv[argi][2] != '\0') {
1507 const char *xml = argv[argi] + 2;
1508 entitlements.open(xml, O_RDONLY, PROT_READ, MAP_PRIVATE);
1509 }
1510 break;
1511
1512 case 'K':
1513 key.open(argv[argi] + 2, O_RDONLY, PROT_READ, MAP_PRIVATE);
1514 break;
1515
1516 case 'T': {
1517 flag_T = true;
1518 if (argv[argi][2] == '-')
1519 timeh = true;
1520 else {
1521 char *arge;
1522 timev = strtoul(argv[argi] + 2, &arge, 0);
1523 _assert(arge == argv[argi] + strlen(argv[argi]));
1524 }
1525 } break;
1526
1527 case 'I': {
1528 flag_I = argv[argi] + 2;
1529 } break;
1530
1531 default:
1532 goto usage;
1533 break;
1534 }
1535
1536 _assert(flag_S || key.empty());
1537 _assert(flag_S || flag_I == NULL);
1538
1539 if (files.empty()) usage: {
1540 exit(0);
1541 }
1542
1543 size_t filei(0), filee(0);
1544 _foreach (file, files) try {
1545 const char *path(file.c_str());
1546 const char *base = strrchr(path, '/');
1547
1548 std::string dir;
1549 if (base != NULL)
1550 dir.assign(path, base++ - path + 1);
1551 else
1552 base = path;
1553
1554 const char *name(flag_I ?: base);
1555 std::string temp;
1556
1557 if (flag_S || flag_r) {
1558 Map input(path, O_RDONLY, PROT_READ, MAP_PRIVATE);
1559
1560 temp = dir + "." + base + ".cs";
1561 std::filebuf output;
1562 _assert(output.open(temp.c_str(), std::ios::out | std::ios::trunc | std::ios::binary) == &output);
1563
1564 if (flag_r)
1565 resign(input.data(), input.size(), output);
1566 else {
1567 resign(input.data(), input.size(), output, name, entitlements, key);
1568 }
1569 }
1570
1571 Map mapping(!temp.empty() ? temp.c_str() : path, flag_T || flag_s);
1572 FatHeader fat_header(mapping.data(), mapping.size());
1573
1574 _foreach (mach_header, fat_header.GetMachHeaders()) {
1575 struct linkedit_data_command *signature(NULL);
1576 struct encryption_info_command *encryption(NULL);
1577
1578 if (flag_A) {
1579 if (mach_header.GetCPUType() != flag_CPUType)
1580 continue;
1581 if (mach_header.GetCPUSubtype() != flag_CPUSubtype)
1582 continue;
1583 }
1584
1585 if (flag_a)
1586 printf("cpu=0x%x:0x%x\n", mach_header.GetCPUType(), mach_header.GetCPUSubtype());
1587
1588 _foreach (load_command, mach_header.GetLoadCommands()) {
1589 uint32_t cmd(mach_header.Swap(load_command->cmd));
1590
1591 if (false);
1592 else if (cmd == LC_CODE_SIGNATURE)
1593 signature = reinterpret_cast<struct linkedit_data_command *>(load_command);
1594 else if (cmd == LC_ENCRYPTION_INFO || cmd == LC_ENCRYPTION_INFO_64)
1595 encryption = reinterpret_cast<struct encryption_info_command *>(load_command);
1596 else if (cmd == LC_ID_DYLIB) {
1597 volatile struct dylib_command *dylib_command(reinterpret_cast<struct dylib_command *>(load_command));
1598
1599 if (flag_T) {
1600 uint32_t timed;
1601
1602 if (!timeh)
1603 timed = timev;
1604 else {
1605 dylib_command->dylib.timestamp = 0;
1606 timed = hash(reinterpret_cast<uint8_t *>(mach_header.GetBase()), mach_header.GetSize(), timev);
1607 }
1608
1609 dylib_command->dylib.timestamp = mach_header.Swap(timed);
1610 }
1611 }
1612 }
1613
1614 if (flag_D) {
1615 _assert(encryption != NULL);
1616 encryption->cryptid = mach_header.Swap(0);
1617 }
1618
1619 if (flag_e) {
1620 _assert(signature != NULL);
1621
1622 uint32_t data = mach_header.Swap(signature->dataoff);
1623
1624 uint8_t *top = reinterpret_cast<uint8_t *>(mach_header.GetBase());
1625 uint8_t *blob = top + data;
1626 struct SuperBlob *super = reinterpret_cast<struct SuperBlob *>(blob);
1627
1628 for (size_t index(0); index != Swap(super->count); ++index)
1629 if (Swap(super->index[index].type) == CSSLOT_ENTITLEMENTS) {
1630 uint32_t begin = Swap(super->index[index].offset);
1631 struct Blob *entitlements = reinterpret_cast<struct Blob *>(blob + begin);
1632 fwrite(entitlements + 1, 1, Swap(entitlements->length) - sizeof(*entitlements), stdout);
1633 }
1634 }
1635
1636 if (flag_s) {
1637 _assert(signature != NULL);
1638
1639 uint32_t data = mach_header.Swap(signature->dataoff);
1640
1641 uint8_t *top = reinterpret_cast<uint8_t *>(mach_header.GetBase());
1642 uint8_t *blob = top + data;
1643 struct SuperBlob *super = reinterpret_cast<struct SuperBlob *>(blob);
1644
1645 for (size_t index(0); index != Swap(super->count); ++index)
1646 if (Swap(super->index[index].type) == CSSLOT_CODEDIRECTORY) {
1647 uint32_t begin = Swap(super->index[index].offset);
1648 struct CodeDirectory *directory = reinterpret_cast<struct CodeDirectory *>(blob + begin);
1649
1650 uint8_t (*hashes)[SHA_DIGEST_LENGTH] = reinterpret_cast<uint8_t (*)[SHA_DIGEST_LENGTH]>(blob + begin + Swap(directory->hashOffset));
1651 uint32_t pages = Swap(directory->nCodeSlots);
1652
1653 if (pages != 1)
1654 for (size_t i = 0; i != pages - 1; ++i)
1655 sha1(hashes[i], top + PageSize_ * i, PageSize_);
1656 if (pages != 0)
1657 sha1(hashes[pages - 1], top + PageSize_ * (pages - 1), ((data - 1) % PageSize_) + 1);
1658 }
1659 }
1660 }
1661
1662 if (!temp.empty()) {
1663 struct stat info;
1664 _syscall(stat(path, &info));
1665 #ifndef __WIN32__
1666 _syscall(chown(temp.c_str(), info.st_uid, info.st_gid));
1667 #endif
1668 _syscall(chmod(temp.c_str(), info.st_mode));
1669 _syscall(unlink(path));
1670 _syscall(rename(temp.c_str(), path));
1671 }
1672
1673 ++filei;
1674 } catch (const char *) {
1675 ++filee;
1676 ++filei;
1677 }
1678
1679 return filee;
1680 }
Link Identity Editor