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