]>
Commit | Line | Data |
---|---|---|
ab113d22 | 1 | /* ldid - (Mach-O) Link-Loader Identity Editor |
16efdde5 | 2 | * Copyright (C) 2007-2015 Jay Freeman (saurik) |
a362a82f JF |
3 | */ |
4 | ||
dd6c06ed JF |
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 | |
e0524446 JF |
9 | * the Free Software Foundation, either version 3 of the License, or |
10 | * (at your option) any later version. | |
dd6c06ed | 11 | |
e0524446 JF |
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 | |
dd6c06ed JF |
15 | * GNU Affero General Public License for more details. |
16 | ||
17 | * You should have received a copy of the GNU Affero General Public License | |
e0524446 JF |
18 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
19 | **/ | |
20 | /* }}} */ | |
a362a82f | 21 | |
fa59c178 JF |
22 | #include <cstdio> |
23 | #include <cstdlib> | |
a362a82f | 24 | #include <cstring> |
4d4682ef JF |
25 | #include <fstream> |
26 | #include <map> | |
27 | #include <sstream> | |
a362a82f JF |
28 | #include <string> |
29 | #include <vector> | |
30 | ||
dede6121 | 31 | #include <dlfcn.h> |
fa59c178 | 32 | #include <errno.h> |
dede6121 | 33 | #include <fcntl.h> |
fa59c178 JF |
34 | #include <stdbool.h> |
35 | #include <stdint.h> | |
dede6121 JF |
36 | |
37 | #include <sys/mman.h> | |
38 | #include <sys/stat.h> | |
39 | ||
a50bb1be JF |
40 | #include <openssl/sha.h> |
41 | ||
15babeef JF |
42 | #include <plist/plist.h> |
43 | ||
fa59c178 JF |
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 | ||
a362a82f JF |
91 | struct fat_header { |
92 | uint32_t magic; | |
93 | uint32_t nfat_arch; | |
c05d9758 | 94 | } _packed; |
a362a82f JF |
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; | |
c05d9758 | 105 | } _packed; |
a362a82f JF |
106 | |
107 | struct mach_header { | |
108 | uint32_t magic; | |
109 | uint32_t cputype; | |
04802ab1 | 110 | uint32_t cpusubtype; |
a362a82f JF |
111 | uint32_t filetype; |
112 | uint32_t ncmds; | |
113 | uint32_t sizeofcmds; | |
114 | uint32_t flags; | |
c05d9758 | 115 | } _packed; |
a362a82f | 116 | |
fdb119ef | 117 | #define MH_MAGIC 0xfeedface |
a362a82f JF |
118 | #define MH_CIGAM 0xcefaedfe |
119 | ||
3cbc6463 JF |
120 | #define MH_MAGIC_64 0xfeedfacf |
121 | #define MH_CIGAM_64 0xcffaedfe | |
122 | ||
82813bde JF |
123 | #define MH_DYLDLINK 0x4 |
124 | ||
4a864785 | 125 | #define MH_OBJECT 0x1 |
efd6cd4a JF |
126 | #define MH_EXECUTE 0x2 |
127 | #define MH_DYLIB 0x6 | |
128 | #define MH_BUNDLE 0x8 | |
129 | #define MH_DYLIB_STUB 0x9 | |
a362a82f JF |
130 | |
131 | struct load_command { | |
132 | uint32_t cmd; | |
133 | uint32_t cmdsize; | |
c05d9758 | 134 | } _packed; |
a362a82f | 135 | |
4a57e66c JF |
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) | |
289ccbbc | 143 | #define LC_SEGMENT_64 uint32_t(0x19) |
4a57e66c JF |
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) | |
c0cc1574 | 148 | #define LC_ENCRYPTION_INFO uint32_t(0x21) |
4a57e66c JF |
149 | #define LC_DYLD_INFO uint32_t(0x22) |
150 | #define LC_DYLD_INFO_ONLY uint32_t(0x22 | LC_REQ_DYLD) | |
843aea8c | 151 | #define LC_ENCRYPTION_INFO_64 uint32_t(0x2c) |
a362a82f JF |
152 | |
153 | struct dylib { | |
154 | uint32_t name; | |
155 | uint32_t timestamp; | |
156 | uint32_t current_version; | |
157 | uint32_t compatibility_version; | |
c05d9758 | 158 | } _packed; |
a362a82f JF |
159 | |
160 | struct dylib_command { | |
161 | uint32_t cmd; | |
162 | uint32_t cmdsize; | |
163 | struct dylib dylib; | |
c05d9758 | 164 | } _packed; |
a362a82f JF |
165 | |
166 | struct uuid_command { | |
167 | uint32_t cmd; | |
168 | uint32_t cmdsize; | |
169 | uint8_t uuid[16]; | |
c05d9758 | 170 | } _packed; |
a362a82f | 171 | |
20e7eb29 JF |
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 | ||
4a57e66c JF |
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 | ||
6e83315b JF |
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; | |
429e34a5 | 278 | } _packed; |
6e83315b | 279 | |
289ccbbc JF |
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; | |
429e34a5 | 292 | } _packed; |
289ccbbc | 293 | |
6e83315b JF |
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; | |
429e34a5 | 306 | } _packed; |
6e83315b | 307 | |
289ccbbc JF |
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; | |
429e34a5 | 320 | } _packed; |
289ccbbc | 321 | |
fdb119ef JF |
322 | struct linkedit_data_command { |
323 | uint32_t cmd; | |
324 | uint32_t cmdsize; | |
325 | uint32_t dataoff; | |
326 | uint32_t datasize; | |
c05d9758 | 327 | } _packed; |
fdb119ef | 328 | |
c0cc1574 JF |
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 | ||
4a864785 JF |
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 | ||
4d4682ef JF |
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 | ||
4374152f JF |
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 | ||
fdb119ef JF |
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 | ||
4374152f JF |
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 | ||
fdb119ef JF |
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 | ||
4374152f JF |
404 | int64_t Swap_(int64_t value) { |
405 | return Swap_(static_cast<uint64_t>(value)); | |
406 | } | |
407 | ||
5525a5a7 JF |
408 | bool little_(true); |
409 | ||
fdb119ef | 410 | uint16_t Swap(uint16_t value) { |
5525a5a7 | 411 | return little_ ? Swap_(value) : value; |
fdb119ef JF |
412 | } |
413 | ||
414 | uint32_t Swap(uint32_t value) { | |
5525a5a7 | 415 | return little_ ? Swap_(value) : value; |
fdb119ef JF |
416 | } |
417 | ||
4374152f JF |
418 | uint64_t Swap(uint64_t value) { |
419 | return little_ ? Swap_(value) : value; | |
420 | } | |
421 | ||
fdb119ef JF |
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 | ||
4374152f JF |
430 | int64_t Swap(int64_t value) { |
431 | return Swap(static_cast<uint64_t>(value)); | |
432 | } | |
433 | ||
6e83315b JF |
434 | template <typename Target_> |
435 | class Pointer; | |
436 | ||
4d4682ef | 437 | class Swapped { |
0a033524 | 438 | protected: |
a362a82f JF |
439 | bool swapped_; |
440 | ||
4d4682ef | 441 | Swapped() : |
0a033524 JF |
442 | swapped_(false) |
443 | { | |
444 | } | |
445 | ||
4d4682ef JF |
446 | public: |
447 | Swapped(bool swapped) : | |
448 | swapped_(swapped) | |
449 | { | |
a362a82f JF |
450 | } |
451 | ||
4d4682ef JF |
452 | template <typename Type_> |
453 | Type_ Swap(Type_ value) const { | |
4374152f JF |
454 | return swapped_ ? Swap_(value) : value; |
455 | } | |
4d4682ef | 456 | }; |
4374152f | 457 | |
4d4682ef JF |
458 | class Data : |
459 | public Swapped | |
460 | { | |
461 | private: | |
462 | void *base_; | |
463 | size_t size_; | |
a362a82f | 464 | |
4d4682ef JF |
465 | public: |
466 | Data(void *base, size_t size) : | |
467 | base_(base), | |
468 | size_(size) | |
469 | { | |
4374152f JF |
470 | } |
471 | ||
0a033524 JF |
472 | void *GetBase() const { |
473 | return base_; | |
474 | } | |
a362a82f | 475 | |
0a033524 JF |
476 | size_t GetSize() const { |
477 | return size_; | |
478 | } | |
479 | }; | |
a362a82f | 480 | |
0a033524 JF |
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; | |
a362a82f | 495 | |
3cbc6463 JF |
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; | |
a362a82f JF |
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 | ||
4d4682ef JF |
525 | bool Bits64() const { |
526 | return bits64_; | |
527 | } | |
528 | ||
afbb7c8e JF |
529 | struct mach_header *operator ->() const { |
530 | return mach_header_; | |
531 | } | |
532 | ||
4374152f JF |
533 | operator struct mach_header *() const { |
534 | return mach_header_; | |
535 | } | |
536 | ||
04802ab1 JF |
537 | uint32_t GetCPUType() const { |
538 | return Swap(mach_header_->cputype); | |
539 | } | |
540 | ||
4374152f | 541 | uint32_t GetCPUSubtype() const { |
04802ab1 JF |
542 | return Swap(mach_header_->cpusubtype) & 0xff; |
543 | } | |
544 | ||
4374152f JF |
545 | struct load_command *GetLoadCommand() const { |
546 | return load_command_; | |
547 | } | |
548 | ||
0a033524 | 549 | std::vector<struct load_command *> GetLoadCommands() const { |
a362a82f JF |
550 | std::vector<struct load_command *> load_commands; |
551 | ||
3cbc6463 | 552 | struct load_command *load_command = load_command_; |
a362a82f JF |
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 | } | |
6e83315b | 560 | |
6f340f51 | 561 | std::vector<segment_command *> GetSegments(const char *segment_name) const { |
6e83315b JF |
562 | std::vector<struct segment_command *> segment_commands; |
563 | ||
289ccbbc | 564 | _foreach (load_command, GetLoadCommands()) { |
0a033524 JF |
565 | if (Swap(load_command->cmd) == LC_SEGMENT) { |
566 | segment_command *segment_command = reinterpret_cast<struct segment_command *>(load_command); | |
6e83315b JF |
567 | if (strncmp(segment_command->segname, segment_name, 16) == 0) |
568 | segment_commands.push_back(segment_command); | |
569 | } | |
289ccbbc JF |
570 | } |
571 | ||
572 | return segment_commands; | |
573 | } | |
574 | ||
4374152f | 575 | std::vector<segment_command_64 *> GetSegments64(const char *segment_name) const { |
289ccbbc JF |
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 | } | |
6e83315b JF |
585 | |
586 | return segment_commands; | |
587 | } | |
588 | ||
6f340f51 | 589 | std::vector<section *> GetSections(const char *segment_name, const char *section_name) const { |
6e83315b JF |
590 | std::vector<section *> sections; |
591 | ||
592 | _foreach (segment, GetSegments(segment_name)) { | |
0a033524 | 593 | section *section = (struct section *) (segment + 1); |
6e83315b JF |
594 | |
595 | uint32_t sect; | |
0a033524 | 596 | for (sect = 0; sect != Swap(segment->nsects); ++sect) { |
6e83315b JF |
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_> | |
0a033524 | 607 | Pointer<Target_> GetPointer(uint32_t address, const char *segment_name = NULL) const { |
6e83315b JF |
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 = §ions[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 | ||
289ccbbc JF |
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 | ||
0a033524 JF |
661 | class FatHeader : |
662 | public Data | |
663 | { | |
664 | private: | |
665 | fat_header *fat_header_; | |
289ccbbc | 666 | std::vector<FatMachHeader> mach_headers_; |
0a033524 JF |
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; | |
289ccbbc | 679 | mach_headers_.push_back(FatMachHeader(base, size, NULL)); |
0a033524 JF |
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); | |
289ccbbc | 687 | mach_headers_.push_back(FatMachHeader((uint8_t *) base + arch_offset, arch_size, fat_arch)); |
0a033524 JF |
688 | ++fat_arch; |
689 | } | |
690 | } | |
691 | } | |
692 | ||
289ccbbc | 693 | std::vector<FatMachHeader> &GetMachHeaders() { |
0a033524 JF |
694 | return mach_headers_; |
695 | } | |
20e7eb29 JF |
696 | |
697 | bool IsFat() const { | |
698 | return fat_header_ != NULL; | |
699 | } | |
6b38c173 JF |
700 | |
701 | struct fat_header *operator ->() const { | |
702 | return fat_header_; | |
703 | } | |
4374152f JF |
704 | |
705 | operator struct fat_header *() const { | |
706 | return fat_header_; | |
707 | } | |
0a033524 JF |
708 | }; |
709 | ||
6e83315b JF |
710 | template <typename Target_> |
711 | class Pointer { | |
712 | private: | |
0a033524 | 713 | const MachHeader *framework_; |
6e83315b JF |
714 | const Target_ *pointer_; |
715 | ||
716 | public: | |
0a033524 | 717 | Pointer(const MachHeader *framework = NULL, const Target_ *pointer = NULL) : |
6e83315b JF |
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 | } | |
a362a82f JF |
740 | }; |
741 | ||
4d4682ef JF |
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) | |
c05d9758 | 750 | |
4d4682ef JF |
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 | |
fdb119ef JF |
761 | |
762 | struct BlobIndex { | |
763 | uint32_t type; | |
764 | uint32_t offset; | |
c05d9758 | 765 | } _packed; |
fdb119ef | 766 | |
c05d9758 | 767 | struct Blob { |
fdb119ef JF |
768 | uint32_t magic; |
769 | uint32_t length; | |
c05d9758 JF |
770 | } _packed; |
771 | ||
772 | struct SuperBlob { | |
773 | struct Blob blob; | |
fdb119ef JF |
774 | uint32_t count; |
775 | struct BlobIndex index[]; | |
c05d9758 | 776 | } _packed; |
fdb119ef JF |
777 | |
778 | struct CodeDirectory { | |
fdb119ef JF |
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; | |
c05d9758 | 791 | } _packed; |
fdb119ef | 792 | |
a362a82f JF |
793 | extern "C" uint32_t hash(uint8_t *k, uint32_t length, uint32_t initval); |
794 | ||
4d4682ef JF |
795 | void sha1(uint8_t *hash, const void *data, size_t size) { |
796 | SHA1(static_cast<const uint8_t *>(data), size, hash); | |
fdb119ef JF |
797 | } |
798 | ||
0a033524 | 799 | struct CodesignAllocation { |
4374152f JF |
800 | FatMachHeader mach_header_; |
801 | uint32_t offset_; | |
802 | uint32_t size_; | |
4d4682ef | 803 | uint32_t limit_; |
4374152f | 804 | uint32_t alloc_; |
e4b7adc1 | 805 | uint32_t align_; |
4374152f | 806 | |
e0098838 | 807 | CodesignAllocation(FatMachHeader mach_header, size_t offset, size_t size, size_t limit, size_t alloc, size_t align) : |
4374152f JF |
808 | mach_header_(mach_header), |
809 | offset_(offset), | |
810 | size_(size), | |
4d4682ef | 811 | limit_(limit), |
e4b7adc1 JF |
812 | alloc_(alloc), |
813 | align_(align) | |
0a033524 JF |
814 | { |
815 | } | |
816 | }; | |
817 | ||
dede6121 JF |
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 | ||
cad40c43 | 833 | void open(const char *path, int flags) { |
dede6121 | 834 | _assert(file_ == -1); |
cad40c43 | 835 | _syscall(file_ = ::open(path, flags)); |
dede6121 JF |
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 | ||
cad40c43 JF |
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); | |
dede6121 JF |
874 | } |
875 | ||
876 | ~Map() { | |
877 | clear(); | |
878 | } | |
879 | ||
cad40c43 | 880 | void open(const char *path, int oflag, int pflag, int mflag) { |
dede6121 JF |
881 | clear(); |
882 | ||
cad40c43 | 883 | file_.open(path, oflag); |
dede6121 JF |
884 | int file(file_.file()); |
885 | ||
886 | struct stat stat; | |
887 | _syscall(fstat(file, &stat)); | |
888 | size_ = stat.st_size; | |
889 | ||
cad40c43 JF |
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); | |
dede6121 JF |
898 | } |
899 | ||
900 | void *data() const { | |
901 | return data_; | |
902 | } | |
903 | ||
904 | size_t size() const { | |
905 | return size_; | |
906 | } | |
f4b2df35 JF |
907 | |
908 | operator std::string() const { | |
909 | return std::string(static_cast<char *>(data_), size_); | |
910 | } | |
dede6121 JF |
911 | }; |
912 | ||
e0098838 | 913 | // I wish Apple cared about providing quality toolchains :/ |
4d4682ef | 914 | |
e0098838 JF |
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); | |
f4b2df35 JF |
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 | ||
e0098838 | 992 | size_t alloc(allocate(size)); |
f4b2df35 JF |
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 | ||
4d4682ef JF |
998 | uint32_t limit(size); |
999 | if (alloc != 0) | |
1000 | limit = Align(limit, 0x10); | |
1001 | ||
e0098838 | 1002 | allocations.push_back(CodesignAllocation(mach_header, offset, size, limit, alloc, align)); |
f4b2df35 JF |
1003 | offset += size + alloc; |
1004 | offset = Align(offset, 16); | |
1005 | } | |
1006 | ||
4d4682ef JF |
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 | } | |
f4b2df35 JF |
1028 | } |
1029 | ||
1030 | _foreach (allocation, allocations) { | |
4d4682ef | 1031 | auto &mach_header(allocation.mach_header_); |
f4b2df35 | 1032 | |
4d4682ef JF |
1033 | pad(output, allocation.offset_ - position); |
1034 | position = allocation.offset_; | |
f4b2df35 | 1035 | |
4d4682ef | 1036 | std::vector<std::string> commands; |
f4b2df35 | 1037 | |
4d4682ef JF |
1038 | _foreach (load_command, mach_header.GetLoadCommands()) { |
1039 | std::string copy(reinterpret_cast<const char *>(load_command), load_command->cmdsize); | |
f4b2df35 | 1040 | |
4d4682ef JF |
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 *>(©[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 *>(©[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 | } | |
f4b2df35 | 1064 | |
4d4682ef | 1065 | commands.push_back(copy); |
f4b2df35 JF |
1066 | } |
1067 | ||
e0098838 | 1068 | if (allocation.alloc_ != 0) { |
4d4682ef JF |
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 | } | |
f4b2df35 | 1076 | |
4d4682ef | 1077 | size_t begin(position); |
f4b2df35 | 1078 | |
4d4682ef JF |
1079 | uint32_t after(0); |
1080 | _foreach(command, commands) | |
1081 | after += command.size(); | |
f4b2df35 | 1082 | |
4d4682ef | 1083 | std::stringbuf altern; |
f4b2df35 | 1084 | |
4d4682ef JF |
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); | |
f4b2df35 | 1091 | |
4d4682ef JF |
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 | } | |
f4b2df35 | 1098 | |
4d4682ef JF |
1099 | _foreach(command, commands) { |
1100 | put(output, command.data(), command.size()); | |
1101 | put(altern, command.data(), command.size()); | |
1102 | position += command.size(); | |
1103 | } | |
f4b2df35 | 1104 | |
4d4682ef JF |
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 | } | |
f4b2df35 | 1111 | |
4d4682ef | 1112 | auto top(reinterpret_cast<char *>(mach_header.GetBase())); |
f4b2df35 | 1113 | |
4d4682ef JF |
1114 | std::string overlap(altern.str()); |
1115 | overlap.append(top + overlap.size(), Align(overlap.size(), 0x1000) - overlap.size()); | |
f4b2df35 | 1116 | |
4d4682ef JF |
1117 | put(output, top + (position - begin), allocation.size_ - (position - begin)); |
1118 | position = begin + allocation.size_; | |
f4b2df35 | 1119 | |
4d4682ef JF |
1120 | pad(output, allocation.limit_ - allocation.size_); |
1121 | position += allocation.limit_ - allocation.size_; | |
f4b2df35 | 1122 | |
67205335 JF |
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_; | |
e0098838 JF |
1127 | } |
1128 | } | |
f4b2df35 | 1129 | |
7c171fd3 | 1130 | void resign(void *idata, size_t isize, std::streambuf &output, const std::string &name, const std::string &entitlements) { |
e0098838 JF |
1131 | uint8_t pageshift(0x0c); |
1132 | uint32_t pagesize(1 << pageshift); | |
f4b2df35 | 1133 | |
e0098838 JF |
1134 | resign(idata, isize, output, fun([&](size_t size) -> size_t { |
1135 | size_t alloc(sizeof(struct SuperBlob)); | |
f4b2df35 | 1136 | |
e0098838 | 1137 | uint32_t special(0); |
f4b2df35 | 1138 | |
e0098838 JF |
1139 | special = std::max(special, CSSLOT_REQUIREMENTS); |
1140 | alloc += sizeof(struct BlobIndex); | |
1141 | alloc += 0xc; | |
f4b2df35 | 1142 | |
e0098838 JF |
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 | } | |
f4b2df35 | 1149 | |
e0098838 JF |
1150 | special = std::max(special, CSSLOT_CODEDIRECTORY); |
1151 | alloc += sizeof(struct BlobIndex); | |
1152 | alloc += sizeof(struct Blob); | |
1153 | alloc += sizeof(struct CodeDirectory); | |
7c171fd3 | 1154 | alloc += name.size() + 1; |
f4b2df35 | 1155 | |
e0098838 JF |
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; | |
f4b2df35 | 1161 | |
e0098838 JF |
1162 | if (true) { |
1163 | std::stringbuf data; | |
f4b2df35 | 1164 | |
e0098838 JF |
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)); | |
4d4682ef | 1169 | |
e0098838 JF |
1170 | uint32_t requirements; |
1171 | requirements = Swap(0); | |
1172 | put(data, &requirements, sizeof(requirements)); | |
4d4682ef | 1173 | |
e0098838 JF |
1174 | blobs.insert(std::make_pair(CSSLOT_REQUIREMENTS, data.str())); |
1175 | } | |
4d4682ef | 1176 | |
e0098838 JF |
1177 | if (entitlements.size() != 0) { |
1178 | std::stringbuf data; | |
f4b2df35 | 1179 | |
e0098838 JF |
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)); | |
4d4682ef | 1184 | |
e0098838 | 1185 | put(data, entitlements.data(), entitlements.size()); |
4d4682ef | 1186 | |
e0098838 JF |
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); | |
7c171fd3 | 1200 | blob.length = Swap(uint32_t(sizeof(blob) + sizeof(CodeDirectory) + name.size() + 1 + SHA_DIGEST_LENGTH * (special + normal))); |
e0098838 JF |
1201 | put(data, &blob, sizeof(blob)); |
1202 | ||
1203 | CodeDirectory directory; | |
1204 | directory.version = Swap(uint32_t(0x00020001)); | |
1205 | directory.flags = Swap(uint32_t(0)); | |
7c171fd3 | 1206 | directory.hashOffset = Swap(uint32_t(sizeof(blob) + sizeof(CodeDirectory) + name.size() + 1 + SHA_DIGEST_LENGTH * special)); |
e0098838 JF |
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 | ||
7c171fd3 | 1218 | put(data, name.c_str(), name.size() + 1); |
e0098838 JF |
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); | |
4d4682ef JF |
1224 | |
1225 | _foreach (blob, blobs) { | |
e0098838 JF |
1226 | auto local(reinterpret_cast<const Blob *>(&blob.second[0])); |
1227 | sha1((uint8_t *) (hashes - blob.first), local, Swap(local->length)); | |
4d4682ef | 1228 | } |
f4b2df35 | 1229 | |
e0098838 JF |
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); | |
f4b2df35 | 1235 | |
e0098838 JF |
1236 | put(data, storage, sizeof(storage)); |
1237 | ||
1238 | blobs.insert(std::make_pair(CSSLOT_CODEDIRECTORY, data.str())); | |
f4b2df35 | 1239 | } |
e0098838 JF |
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 | })); | |
f4b2df35 JF |
1274 | } |
1275 | ||
a362a82f | 1276 | int main(int argc, const char *argv[]) { |
5525a5a7 JF |
1277 | union { |
1278 | uint16_t word; | |
1279 | uint8_t byte[2]; | |
1280 | } endian = {1}; | |
1281 | ||
1282 | little_ = endian.byte[0]; | |
1283 | ||
20e7eb29 | 1284 | bool flag_r(false); |
9c83be90 | 1285 | bool flag_e(false); |
a362a82f JF |
1286 | |
1287 | bool flag_T(false); | |
20c5f1e8 | 1288 | |
fdb119ef | 1289 | bool flag_S(false); |
20c5f1e8 | 1290 | bool flag_s(false); |
a362a82f | 1291 | |
c0cc1574 | 1292 | bool flag_D(false); |
c0cc1574 | 1293 | |
8c417842 JF |
1294 | bool flag_A(false); |
1295 | bool flag_a(false); | |
1296 | ||
c0cc1574 JF |
1297 | uint32_t flag_CPUType(_not(uint32_t)); |
1298 | uint32_t flag_CPUSubtype(_not(uint32_t)); | |
1299 | ||
5d7ceb5d JF |
1300 | const char *flag_I(NULL); |
1301 | ||
a362a82f JF |
1302 | bool timeh(false); |
1303 | uint32_t timev(0); | |
1304 | ||
4d4682ef | 1305 | Map entitlements; |
c05d9758 | 1306 | |
a362a82f JF |
1307 | std::vector<std::string> files; |
1308 | ||
a960f392 JF |
1309 | if (argc == 1) { |
1310 | fprintf(stderr, "usage: %s -S[entitlements.xml] <binary>\n", argv[0]); | |
9c83be90 | 1311 | fprintf(stderr, " %s -e MobileSafari\n", argv[0]); |
a960f392 JF |
1312 | fprintf(stderr, " %s -S cat\n", argv[0]); |
1313 | fprintf(stderr, " %s -Stfp.xml gdb\n", argv[0]); | |
1314 | exit(0); | |
1315 | } | |
1316 | ||
a362a82f JF |
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]) { | |
20e7eb29 | 1321 | case 'r': flag_r = true; break; |
9c83be90 | 1322 | case 'e': flag_e = true; break; |
c05d9758 | 1323 | |
c0cc1574 | 1324 | case 'D': flag_D = true; break; |
c0cc1574 | 1325 | |
8c417842 JF |
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 | ||
20c5f1e8 JF |
1342 | case 's': |
1343 | _assert(!flag_S); | |
1344 | flag_s = true; | |
1345 | break; | |
1346 | ||
c05d9758 | 1347 | case 'S': |
20c5f1e8 | 1348 | _assert(!flag_s); |
c05d9758 JF |
1349 | flag_S = true; |
1350 | if (argv[argi][2] != '\0') { | |
1351 | const char *xml = argv[argi] + 2; | |
4d4682ef | 1352 | entitlements.open(xml, O_RDONLY, PROT_READ, MAP_PRIVATE); |
c05d9758 JF |
1353 | } |
1354 | break; | |
a362a82f JF |
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 | ||
5d7ceb5d JF |
1367 | case 'I': { |
1368 | flag_I = argv[argi] + 2; | |
1369 | } break; | |
1370 | ||
a362a82f JF |
1371 | default: |
1372 | goto usage; | |
1373 | break; | |
1374 | } | |
1375 | ||
f4b2df35 JF |
1376 | _assert(!flag_S || !flag_r); |
1377 | ||
a362a82f JF |
1378 | if (files.empty()) usage: { |
1379 | exit(0); | |
1380 | } | |
1381 | ||
1382 | size_t filei(0), filee(0); | |
1383 | _foreach (file, files) try { | |
0a033524 | 1384 | const char *path(file.c_str()); |
fdb119ef | 1385 | const char *base = strrchr(path, '/'); |
fdb119ef | 1386 | |
b7c20a6d | 1387 | std::string dir; |
fdb119ef | 1388 | if (base != NULL) |
b7c20a6d JF |
1389 | dir.assign(path, base++ - path + 1); |
1390 | else | |
fdb119ef | 1391 | base = path; |
fdb119ef | 1392 | |
5d7ceb5d | 1393 | const char *name(flag_I ?: base); |
b7c20a6d | 1394 | char *temp(NULL); |
5d7ceb5d | 1395 | |
cad40c43 | 1396 | if (flag_S || flag_r) { |
4d4682ef JF |
1397 | Map input(path, O_RDONLY, PROT_READ, MAP_PRIVATE); |
1398 | ||
1399 | std::filebuf output; | |
b7c20a6d | 1400 | asprintf(&temp, "%s.%s.cs", dir.c_str(), base); |
4d4682ef JF |
1401 | _assert(output.open(temp, std::ios::out | std::ios::trunc | std::ios::binary) == &output); |
1402 | ||
e0098838 JF |
1403 | if (flag_r) |
1404 | resign(input.data(), input.size(), output); | |
1405 | else { | |
1406 | resign(input.data(), input.size(), output, name, entitlements); | |
1407 | } | |
fdb119ef JF |
1408 | } |
1409 | ||
f4b2df35 | 1410 | Map mapping(temp ?: path, flag_T || flag_s); |
dede6121 | 1411 | FatHeader fat_header(mapping.data(), mapping.size()); |
a362a82f | 1412 | |
0a033524 | 1413 | _foreach (mach_header, fat_header.GetMachHeaders()) { |
d840a088 | 1414 | struct linkedit_data_command *signature(NULL); |
7b496abd JF |
1415 | struct encryption_info_command *encryption(NULL); |
1416 | ||
8c417842 JF |
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 | ||
0a033524 JF |
1427 | _foreach (load_command, mach_header.GetLoadCommands()) { |
1428 | uint32_t cmd(mach_header.Swap(load_command->cmd)); | |
1429 | ||
cad40c43 | 1430 | if (false); |
0a033524 JF |
1431 | else if (cmd == LC_CODE_SIGNATURE) |
1432 | signature = reinterpret_cast<struct linkedit_data_command *>(load_command); | |
843aea8c | 1433 | else if (cmd == LC_ENCRYPTION_INFO || cmd == LC_ENCRYPTION_INFO_64) |
7b496abd | 1434 | encryption = reinterpret_cast<struct encryption_info_command *>(load_command); |
cad40c43 | 1435 | else if (cmd == LC_ID_DYLIB) { |
0a033524 | 1436 | volatile struct dylib_command *dylib_command(reinterpret_cast<struct dylib_command *>(load_command)); |
a362a82f | 1437 | |
0a033524 JF |
1438 | if (flag_T) { |
1439 | uint32_t timed; | |
a362a82f | 1440 | |
0a033524 JF |
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 | } | |
a362a82f | 1447 | |
0a033524 JF |
1448 | dylib_command->dylib.timestamp = mach_header.Swap(timed); |
1449 | } | |
7b496abd JF |
1450 | } |
1451 | } | |
1452 | ||
7b496abd JF |
1453 | if (flag_D) { |
1454 | _assert(encryption != NULL); | |
1455 | encryption->cryptid = mach_header.Swap(0); | |
a362a82f | 1456 | } |
a362a82f | 1457 | |
0a033524 JF |
1458 | if (flag_e) { |
1459 | _assert(signature != NULL); | |
9c83be90 | 1460 | |
0a033524 | 1461 | uint32_t data = mach_header.Swap(signature->dataoff); |
9c83be90 | 1462 | |
0a033524 JF |
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); | |
9c83be90 | 1466 | |
0a033524 JF |
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 | } | |
9c83be90 | 1474 | |
0a033524 JF |
1475 | if (flag_s) { |
1476 | _assert(signature != NULL); | |
20c5f1e8 | 1477 | |
0a033524 | 1478 | uint32_t data = mach_header.Swap(signature->dataoff); |
20c5f1e8 | 1479 | |
0a033524 JF |
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); | |
20c5f1e8 | 1483 | |
0a033524 JF |
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); | |
20c5f1e8 | 1488 | |
4d4682ef | 1489 | uint8_t (*hashes)[SHA_DIGEST_LENGTH] = reinterpret_cast<uint8_t (*)[SHA_DIGEST_LENGTH]>(blob + begin + Swap(directory->hashOffset)); |
0a033524 | 1490 | uint32_t pages = Swap(directory->nCodeSlots); |
20c5f1e8 | 1491 | |
0a033524 JF |
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 | } | |
fdb119ef JF |
1499 | } |
1500 | ||
0a033524 | 1501 | if (temp != NULL) { |
31ad673b JF |
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)); | |
fdb119ef JF |
1506 | _syscall(unlink(path)); |
1507 | _syscall(rename(temp, path)); | |
1508 | free(temp); | |
1509 | } | |
1510 | ||
a362a82f JF |
1511 | ++filei; |
1512 | } catch (const char *) { | |
1513 | ++filee; | |
1514 | ++filei; | |
1515 | } | |
1516 | ||
1517 | return filee; | |
1518 | } |