Chameleon

Chameleon Svn Source Tree

Root/branches/meklort/i386/modules/KextPatcher/kext_patcher.c

Source at commit 613 created 13 years 5 months ago.
By meklort, Typo fix
1␉/*␊
2 * Copyright (c) 2010 Evan Lojewski. All rights reserved.␊
3 *␉␊
4 *␉KextPather␊
5 *␉This is an experimental module that I'm looking into implimenting.␊
6 *␉The main purpose is to replace the need for programs such as ␊
7 * NetbookInstaller's kext patching routines. THis way, Apple's kexts can be␊
8 * patched whe loaded instead. (eg: GMA950 kext, Bluetooth + Wifi kexts)␊
9 */␊
10␊
11#include "libsaio.h"␊
12#include "zlib.h"␊
13#include "kext_patcher.h"␊
14#include "boot.h"␊
15#include "bootstruct.h"␊
16#include "pci.h"␊
17#include "drivers.h"␊
18#include "mkext.h"␊
19#include "modules.h"␊
20#include "hex_editor.h"␊
21␊
22␊
23#define kHDACodec␉␉␉␉"HDACodec"␉␉␉␉/* acpi_patcher.c */␊
24␊
25␊
26#ifndef DEBUG_KEXT_PATCHER␊
27#define DEBUG_KEXT_PATCHER 0␊
28#endif␊
29␊
30#if DEBUG_KEXT_PATCHER␊
31#define DBG(x...)␉printf(x)␊
32#else␊
33#define DBG(x...)␊
34#endif␊
35bool patch_kext(TagPtr plist, char* plistbuffer, void* start);␊
36bool patch_gma_kexts(TagPtr plist, char* plistbuffer, void* start);␊
37bool patch_bcm_kext(TagPtr plist, char* plistbuffer, void* start);␊
38bool patch_hda_kext(TagPtr plist, char* plistbuffer, void* start);␊
39bool patch_hda_controller(TagPtr plist, char* plistbuffer, void* start);␊
40␊
41int chartohex(char c);␊
42␊
43static void * z_alloc(void *, u_int items, u_int size);␊
44static void z_free(void *, void *ptr);␊
45␊
46uint16_t patch_gma_deviceid = 0;␊
47uint16_t patch_bcm_deviceid = 0;␊
48// TODO: add detection code / a method for users to enter the id␊
49uint16_t patch_hda_codec = 0;␊
50␊
51#define NEEDS_PATCHING␉␉(patch_bcm_deviceid || patch_gma_deviceid || patch_hda_codec)␊
52␊
53typedef struct z_mem {␊
54 uint32_t alloc_size;␊
55 uint8_t data[0];␊
56} z_mem;␊
57␊
58/*␊
59 * Space allocation and freeing routines for use by zlib routines.␊
60 */␊
61void *␊
62z_alloc(void * notused __unused, u_int num_items, u_int size)␊
63{␊
64 void * result = NULL;␊
65 z_mem * zmem = NULL;␊
66 uint32_t total = num_items * size;␊
67 uint32_t allocSize = total + sizeof(zmem);␊
68 ␊
69 zmem = (z_mem *)malloc(allocSize);␊
70 if (!zmem) {␊
71 goto finish;␊
72 }␊
73 zmem->alloc_size = allocSize;␊
74 result = (void *)&(zmem->data);␊
75finish:␊
76 return result;␊
77}␊
78␊
79void␊
80z_free(void * notused __unused, void * ptr)␊
81{␊
82 uint32_t * skipper = (uint32_t *)ptr - 1;␊
83 z_mem * zmem = (z_mem *)skipper;␊
84 free((void *)zmem);␊
85 return;␊
86}␊
87␊
88␊
89unsigned long Mkext_Alder32( unsigned char * buffer, long length );␊
90␊
91void KextPatcher_hook(void* current, void* arg2, void* arg3, void* arg4);␊
92␊
93/**␊
94 ** KextPatcher_start -> module start␊
95 **␉␉Notified the module system that this module will hook into the ␊
96 **␉␉LoadMatchedModules and LoadDriverMKext functions␊
97 **/␊
98void KextPatcher_start()␊
99{␉␉␊
100␉// Hooks into the following:␊
101␉//␉execute_hook("LoadDriverMKext", (void*)package, (void*) length, NULL, NULL);␊
102␉// execute_hook("LoadMatchedModules", module, &length, executableAddr, NULL);␊
103␊
104␉register_hook_callback("PCIDevice", &KextPatcher_hook);␊
105␉//register_hook_callback("LoadMatchedModules", &kext_loaded); ␊
106␉register_hook_callback("LoadDriverMKext", &mkext_loaded); ␊
107␊
108}␊
109␊
110/**␊
111 ** kext_loaded -> Called whenever a kext is in read into memory␊
112 **␉␉This function will be used to patch kexts ( eg AppleInteIntegratedFramebuffer)␊
113 **␉␉and their plists when they are loaded into memmory␊
114 **/␊
115void kext_loaded(void* moduletmp, void* lengthprt, void* executableAddr, void* arg3)␊
116{␊
117␉␊
118␉//ModulePtr module = moduletmp;␊
119␉//long length = *(long*)lengthprt;␊
120␉//long length2 = strlen(module->plistAddr);␊
121␉// *(long*)lengthprt = length2 + 5 * 1024 * 1024;␊
122␊
123␉//printf("Loading %s, lenght is %d, executable is 0x%X\n", module->plistAddr, length, executableAddr);␊
124␉//getc();␊
125}␊
126␊
127/**␊
128 ** mkext_loaded -> Called whenever an mkext is in read into memory␊
129 **␉␉This function will be used to patch mkext. Matching kexts will be␊
130 **␉␉Extracted, modified, and then compressed again. Note: I need to determine␊
131 **␉␉what sort of slowdown this will cause and if it's worth implimenting.␊
132 **/␊
133␊
134void mkext_loaded(void* filespec, void* packagetmp, void* lengthtmp, void* arg3)␊
135{␊
136␉const char* hda_codec;␊
137␉int len = 0;␊
138␉␊
139␉if (getValueForKey(kHDACodec, &hda_codec, &len, &bootInfo->bootConfig))␊
140␉{␊
141␉␉int index = 0;␊
142␉␉while(len)␊
143␉␉{␊
144␉␉␉patch_hda_codec <<= 4;␊
145␉␉␉patch_hda_codec |= chartohex(hda_codec[index]);␊
146␉␉␉len--;␊
147␉␉␉index++;␊
148␉␉}␊
149␉}␊
150␉␉␊
151␉if(!NEEDS_PATCHING) return;␉// No need to apply a patch, hardware doesn't need it␊
152␉␊
153␉int version = 0;␊
154␉//int length = *((int*)lengthtmp);␊
155␉mkext_basic_header* package = packagetmp;␊
156␊
157␉// Verify the MKext.␊
158 if (( MKEXT_GET_MAGIC(package)␉␉!= MKEXT_MAGIC ) ||␊
159 ( MKEXT_GET_SIGNATURE(package)␉!= MKEXT_SIGN ) ||␊
160 ( MKEXT_GET_LENGTH(package)␉␉> kLoadSize )␉ ||␊
161 ( MKEXT_GET_CHECKSUM(package) !=␊
162␉␉ Mkext_Alder32((unsigned char *)&package->version, MKEXT_GET_LENGTH(package) - 0x10) ) )␊
163 {␊
164 return;␊
165␉␉// Don't try to patch a b␊
166 }␉␊
167␉␊
168␉/*␊
169␉if(strcmp(filespec, "/System/Library/Caches/com.apple.kext.caches/Startup/Extensions.mkext") == 0)␊
170␉{␊
171␉␉printf("Invalidating mkext %s\n", filespec);␊
172␉␉// 10.6 cache folder. Doesn't contain certain extensions we need, so invalidate it.␊
173␉␉//package->adler32++;␊
174␉␉// NOTE: double check that this is needed␊
175␉␉package->magic = 0x00;␊
176␉␉return;␊
177␉}*/␊
178␉␊
179␉␊
180␉version = MKEXT_GET_VERSION(package);␊
181␉␊
182␉if(version == 0x01008000) // mkext1␊
183␉{␊
184␉␉// mkext1 uses lzss␊
185␉␉mkext1_header* package = packagetmp;␊
186␉␉int i;␊
187␉␉for(i = 0; i < MKEXT_GET_COUNT(package); i++)␊
188␉␉{␊
189␉␉␉DBG("Parsing kext %d\n", i);␊
190␉␉␉//mkext_kext* kext = MKEXT1_GET_KEXT(package, i);␊
191␉␉␉// uses decompress_lzss␊
192␉␉␉// TODO: handle kext␊
193␊
194␉␉}␊
195␉}␊
196␉else if((version & 0xFFFF0000) == 0x02000000) // mkext2␊
197␉{␊
198␉␉DBG("Mkext2 package located at 0x%X\n", package);␊
199␊
200␉␉// mkext2 uses zlib␉␉␊
201␉␉mkext2_header* package = packagetmp;␊
202␉␉z_stream zstream;␊
203␉␉bool zstream_inited = false;␊
204␉␉int zlib_result;␊
205␉␉int plist_offset = MKEXT2_GET_PLIST(package);␊
206␉␉␊
207␉␉char* plist = malloc(MKEXT2_GET_PLIST_FULLSIZE(package));␊
208␉␉␊
209␉␉bzero(&zstream, sizeof(zstream));␉␉␊
210␉␉zstream.next_in = (UInt8*)((char*)package + plist_offset);␊
211␉␉zstream.avail_in = MKEXT2_GET_PLIST_COMPSIZE(package);␊
212␉␉␊
213␉␉zstream.next_out = (UInt8*)plist;␊
214␉␉zstream.avail_out = MKEXT2_GET_PLIST_FULLSIZE(package);␊
215␉␉␊
216␉␉zstream.zalloc = z_alloc;␊
217␉␉zstream.zfree = z_free;␊
218␉␉␉␉␊
219␉␉zlib_result = inflateInit(&zstream);␊
220␉␉if (Z_OK != zlib_result)␊
221␉␉{␊
222␉␉␉printf("ZLIB Error: %s\n", zstream.msg);␊
223␉␉␉getc();␊
224␉␉}␊
225␉␉else ␊
226␉␉{␊
227␉␉␉zstream_inited = true;␊
228␉␉}␊
229␊
230␉␉␊
231␉␉zlib_result = inflate(&zstream, Z_FINISH);␊
232␉␉if (zstream_inited) inflateEnd(&zstream);␊
233␊
234␉␉DBG("Inflated result is %d, in: %d bytes, out: %d bytes\n", zlib_result, zstream.total_in, zstream.total_out);␊
235␉␉if (zlib_result == Z_STREAM_END || zlib_result == Z_OK)␊
236␉␉{␉␉␉␊
237␉␉␉config_file_t plistData;␊
238␉␉␉config_file_t allDicts;␊
239␉␉␉bzero(&plistData, sizeof(plistData));␊
240␉␉␉bzero(&allDicts, sizeof(allDicts));␊
241␉␉␉␊
242␉␉␉XMLParseFile( plist, &plistData.dictionary );␊
243␊
244␉␉␉int count = 0;␊
245␊
246␉␉␉allDicts.dictionary = XMLGetProperty(plistData.dictionary, kMKEXTInfoDictionariesKey);␊
247␉␉␉count = XMLTagCount(allDicts.dictionary);␊
248␊
249␉␉␉DBG("Plist contains %d kexts\n", count);␊
250␉␉␉␊
251␉␉␉␊
252␉␉␉bool patched = false;␊
253␉␉␉for(; count--; count > 0)␊
254␉␉␉{␊
255␉␉␉␉TagPtr kextEntry = XMLGetElement(allDicts.dictionary, count);␊
256␉␉␉␉patched |= patch_kext(kextEntry, plist, package);␊
257␉␉␉}␊
258␉␉␉␊
259␊
260␉␉␉if(patched)␊
261␉␉␉{␊
262␉␉␉␉zstream_inited = false;␊
263␉␉␉␉// Recompress the plist␊
264␉␉␉␉bzero(&zstream, sizeof(zstream));␉␉␊
265␉␉␉␉zstream.next_in = (UInt8*)plist;␊
266␉␉␉␉zstream.next_out = (UInt8*)package + plist_offset;␊
267␉␉␉␉zstream.avail_in = MKEXT2_GET_PLIST_FULLSIZE(package);␊
268␉␉␉␉zstream.avail_out = MKEXT2_GET_PLIST_FULLSIZE(package)<<2;␉// Give us some extra free space, just in case␊
269␉␉␉␉zstream.zalloc = Z_NULL;␊
270␉␉␉␉zstream.zfree = Z_NULL;␊
271␉␉␉␉zstream.opaque = Z_NULL;␊
272␉␉␉␉␊
273␉␉␉␉␊
274␉␉␉␉zlib_result = deflateInit2(&zstream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,15, 8 /* memLevel */, Z_DEFAULT_STRATEGY);␊
275␉␉␉␉if (Z_OK != zlib_result) {␊
276␉␉␉␉␉printf("ZLIB Deflate Error: %s\n", zstream.msg);␊
277␉␉␉␉␉getc();␊
278␉␉␉␉}␊
279␉␉␉␉else ␊
280␉␉␉␉{␊
281␉␉␉␉␉zstream_inited = true;␊
282␉␉␉␉}␊
283␉␉␉␉␊
284␉␉␉␉zlib_result = deflate(&zstream, Z_FINISH);␊
285␉␉␉␉␊
286␉␉␉␉if (zlib_result == Z_STREAM_END)␊
287␉␉␉␉{␊
288␉␉␉␉␉DBG("Deflated result is %d, in: %d bytes, out: %d bytes, full: %d\n", zlib_result, zstream.total_in, zstream.total_out, MKEXT2_GET_PLIST_FULLSIZE(package));␊
289␉␉␉␉} ␊
290␉␉␉␉else if (zlib_result == Z_OK)␊
291␉␉␉␉{␊
292␉␉␉␉␉/* deflate filled output buffer, meaning the data doesn't compress.␊
293␉␉␉␉␉ */␊
294␉␉␉␉␉DBG("Deflated result is %d, in: %d bytes, out: %d bytes, full: %d\n", zlib_result, zstream.total_in, zstream.total_out, MKEXT2_GET_PLIST_FULLSIZE(package));␊
295␉␉␉␉␉␊
296␉␉␉␉} ␊
297␉␉␉␉else if (zlib_result != Z_STREAM_ERROR)␊
298␉␉␉␉{␊
299␉␉␉␉␉printf("ZLIB Deflate Error: %s\n", zstream.msg);␊
300␉␉␉␉␉getc();␊
301␉␉␉␉}␊
302␉␉␉␉␊
303␉␉␉␉if(zstream.total_out != MKEXT2_GET_PLIST_COMPSIZE(package))␊
304␉␉␉␉{␊
305␉␉␉␉␉// Update the mkext length␊
306␉␉␉␉␉MKEXT2_HDR_CAST(package)->length = MKEXT_SWAP(MKEXT_GET_LENGTH(package) - MKEXT2_GET_PLIST_COMPSIZE(package) + zstream.total_out);␊
307␉␉␉␉␉MKEXT2_HDR_CAST(package)->plist_compressed_size = MKEXT_SWAP(zstream.total_out);␊
308␉␉␉␉␉*((int*)lengthtmp) -= MKEXT2_GET_PLIST_COMPSIZE(package);␊
309␉␉␉␉␉*((int*)lengthtmp) += zstream.total_out;␊
310␉␉␉␉}␊
311␉␉␉␉␉␉␉␉␊
312␉␉␉␉if (zstream_inited) deflateEnd(&zstream);␊
313␉␉␉␉␊
314␉␉␉␉␊
315␉␉␉␉␊
316␉␉␉␉// re alder32 the new mkext2 package␊
317␉␉␉␉MKEXT_HDR_CAST(package)->adler32 = ␊
318␉␉␉␉␉MKEXT_SWAP(Mkext_Alder32((unsigned char *)&package->version,␊
319␉␉␉␉␉␉␉␉␉␉␉ MKEXT_GET_LENGTH(package) - 0x10));␊
320␉␉␉}␊
321␉␉}␊
322␉␉else␊
323␉␉{␊
324␉␉␉printf("ZLIB Error: %s\n", zstream.msg);␊
325␉␉␉getc();␊
326␉␉}␊
327␊
328␉␉//config_file_t mkextPlist;␊
329␉␉//ParseXMLFile((char*) plist, &mkextPlist.dictionary);␊
330␉␉␊
331␉␉␊
332␉␉␊
333␉␉␊
334␉␉␊
335␉␉/*␉␉int i;␊
336␉␉for(i = 0; i < MKEXT_GET_COUNT(package); i++)␊
337␉␉{␊
338␉␉␉printf("Parsing kext %d\n", i);␊
339␉␉}␊
340␉␉*/␊
341␉␉␊
342␊
343␉}␊
344␊
345␉␊
346␉DBG("Loading %s, version 0x%x\n", filespec, version);␊
347␉//getc();␊
348}␊
349␊
350// FIXME: only handles mkext2 entries␊
351bool patch_kext(TagPtr plist, char* plistbuffer, void* start)␊
352{␊
353␉char* bundleID;␊
354␉␊
355␉if(XMLGetProperty(plist, kMKEXTExecutableKey) == NULL) return false;␉// Kext is a plist only kext, don't patch␊
356␉␊
357␉bundleID = XMLCastString(XMLGetProperty(plist, kPropCFBundleIdentifier));␊
358␉␊
359␉␊
360␉if(patch_gma_deviceid &&␊
361␉ (␊
362␉␉␉(strcmp(bundleID, "com.apple.driver.AppleIntelGMA950") == 0) ||␊
363␉␉␉(strcmp(bundleID, "com.apple.driver.AppleIntelIntegratedFramebuffer") == 0)␊
364␉␉ )␊
365␉ )␊
366␉{␊
367␉␉return patch_gma_kexts(plist, plistbuffer, start);␊
368␉}␊
369␉else if(patch_bcm_deviceid && (strcmp(bundleID, "com.apple.driver.AirPortBrcm43xx") == 0))␊
370␉{␊
371␉␉return patch_bcm_kext(plist, plistbuffer, start);␊
372␊
373␉}␊
374␉else if(patch_hda_codec && strcmp(bundleID, "com.apple.driver.AppleHDA") == 0)␊
375␉{␊
376␉␉return patch_hda_kext(plist, plistbuffer, start);␊
377␊
378␉}␊
379␉/*␊
380␉else if(patch_hda_codec && strcmp(bundleID, "com.apple.driver.AppleHDAController") == 0)␊
381␉{␊
382␉␉return patch_hda_controller(plist, plistbuffer, start);␊
383␊
384␉}␊
385␉*/␊
386␉return false;␊
387}␊
388␊
389void KextPatcher_hook(void* arg1, void* arg2, void* arg3, void* arg4)␊
390{␊
391␉pci_dt_t* current = arg1;␊
392␉if(current)␊
393␉{␊
394␉␉switch(current->class_id)␊
395␉␉{␊
396␉␉␉case PCI_CLASS_DISPLAY_VGA:␊
397␉␉␉␉if(current->vendor_id == 0x8086 && ␊
398␉␉␉␉ (␊
399␉␉␉␉␉current->device_id == 0x27AE /*||␊
400␉␉␉␉␉␊
401␉␉␉␉␉current->device_id == 0xA001 ||␊
402␉␉␉␉␉current->device_id == 0xA002 ||␊
403␉␉␉␉␉current->device_id == 0xA011 ||␊
404␉␉␉␉␉current->device_id == 0xA012␊
405␉␉␉␉␉ */␊
406␉␉␉␉␉␊
407␉␉␉␉␉)␊
408␉␉␉␉ )␊
409␉␉␉␉{␊
410␉␉␉␉␉patch_gma_deviceid = current->device_id;␊
411␉␉␉␉}␊
412␉␉␉␉break;␊
413␉␉␉␉␊
414␉␉␉case PCI_CLASS_NETWORK_OTHER:␊
415␉␉␉␉␊
416␉␉␉␉// Patch BCM43xx␊
417␉␉␉␉if(current->vendor_id == 0x14E4 && ((current->device_id & 0xFF00) == 0x4300))␊
418␉␉␉␉{␊
419␉␉␉␉␉patch_bcm_deviceid = current->device_id;␊
420␉␉␉␉}␊
421␉␉␉␉break;␊
422␉␉}␊
423␉}␊
424}␊
425␊
426␊
427bool patch_hda_controller(TagPtr plist, char* plistbuffer, void* start)␊
428{␊
429␉return false;␊
430␉// change the PCI class code to match to. Note: A LegacyHDA plist should do this on it's own␊
431␉// As such, it's disabled␊
432␊
433␉// TODO: read class code␊
434␉TagPtr personality;␊
435␉personality =␉␉XMLCastDict(XMLGetProperty(plist, kPropIOKitPersonalities));␊
436␉personality =␉␉XMLGetProperty(personality, (const char*)"BuiltInHDA");␉␊
437␉TagPtr match_class =XMLCastArray(XMLGetProperty(personality, (const char*)"IOPCIClassMatch"));␊
438␉␊
439␉␊
440␉char* new_str = malloc(strlen("0xXXXX000&0xFFFE0000")+1);␊
441␉sprintf(new_str, "0x04030000&amp;0xFFFE0000"); // todo, pass in actual class id␊
442␉␊
443␉␊
444␉char* orig_string = "0x04020000&amp;0xFFFE0000"; //XMLCastString(match_class);␊
445␉␊
446␉DBG("Attemting to replace '%s' with '%s'\n", orig_string, new_str);␊
447␉␊
448␉// TODO: verify string doesn't exist first.␊
449␉␊
450␉replace_string(orig_string, new_str, plistbuffer + XMLCastStringOffset(match_class), 10240);␊
451␉␊
452␉return true;␊
453␉␊
454}␊
455␊
456␊
457bool patch_hda_kext(TagPtr plist, char* plistbuffer, void* start)␊
458{␊
459␉uint16_t find_codec = 0;␊
460␉int full_size, compressed_size, executable_offset;␊
461␉void* compressed_data;␊
462␉mkext2_file_entry* kext;␊
463␉int zlib_result;␊
464␉z_stream zstream;␊
465␉bool zstream_inited = false;␊
466␊
467␉switch(0xFF00 & patch_hda_codec)␊
468␉{␊
469␉␉case 0x0200:␊
470␉␉␉find_codec = 0x0262;␊
471␉␉␉break;␊
472␊
473␉␉case 0x0800:␊
474␉␉␉find_codec = 0x0885;␊
475␉␉␉break;␊
476␉␉␉␊
477␉␉case 0x0600:␉// specificaly the 662␊
478␉␉␉find_codec = 0x0885;␊
479␉␉␉break;␊
480␉}␊
481␉␊
482␉if(!find_codec) return false;␉// notify caller that we aren't patching the kext␊
483␊
484␉␉␊
485␉executable_offset = XMLCastInteger(XMLGetProperty(plist, kMKEXTExecutableKey));␊
486␉kext = (void*)((char*)start + executable_offset);␊
487␊
488␉full_size = MKEXT2_GET_ENTRY_FULLSIZE(kext);␊
489␉compressed_size = MKEXT2_GET_ENTRY_COMPSIZE(kext);␊
490␉compressed_data = MKEXT2_GET_ENTRY_DATA(kext);␉␊
491␉executable_offset = XMLCastInteger(XMLGetProperty(plist, kMKEXTExecutableKey));␊
492␉␊
493␉␊
494␉char* executable = malloc(full_size);␊
495␉␊
496␉bzero(&zstream, sizeof(zstream));␉␉␊
497␉zstream.next_in = (UInt8*)compressed_data;␊
498␉zstream.avail_in = compressed_size;␊
499␉␊
500␉zstream.next_out = (UInt8*)executable;␊
501␉zstream.avail_out = full_size;␊
502␉␊
503␉zstream.zalloc = z_alloc;␊
504␉zstream.zfree = z_free;␊
505␉␊
506␉zlib_result = inflateInit(&zstream);␊
507␉if (Z_OK != zlib_result)␊
508␉{␊
509␉␉printf("ZLIB Inflate Error: %s\n", zstream.msg);␊
510␉␉getc();␊
511␉}␊
512␉else ␊
513␉{␊
514␉␉zstream_inited = true;␊
515␉}␊
516␉␊
517␉␊
518␉zlib_result = inflate(&zstream, Z_FINISH);␊
519␉␊
520␉DBG("Inflated result is %d, in: %d bytes, out: %d bytes, full: %d\n", zlib_result, zstream.total_in, zstream.total_out, full_size);␊
521␉␉␊
522␉replace_word(0x10EC | (find_codec << 16), 0xE10EC | (patch_hda_codec << 16), executable, zstream.total_out);␊
523␉␊
524␉if (zstream_inited) inflateEnd(&zstream);␊
525␉␊
526␉␊
527␉zstream.next_in = (UInt8*)executable;␊
528␉zstream.next_out = (UInt8*)compressed_data;␊
529␉␊
530␉zstream.avail_in = full_size;␊
531␉zstream.avail_out = compressed_size;␊
532␉zstream.zalloc = Z_NULL;␊
533␉zstream.zfree = Z_NULL;␊
534␉zstream.opaque = Z_NULL;␊
535␉␊
536␉␊
537␉␊
538␉// Recompress the eecutable␊
539␉zlib_result = deflateInit2(&zstream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,15, 8 /* memLevel */, Z_DEFAULT_STRATEGY);␊
540␉if (Z_OK != zlib_result) {␊
541␉␉printf("ZLIB Deflate Error: %s\n", zstream.msg);␊
542␉␉getc();␊
543␉}␊
544␉else ␊
545␉{␊
546␉␉zstream_inited = true;␊
547␉}␊
548␉␊
549␉zlib_result = deflate(&zstream, Z_FINISH);␊
550␉␊
551␉if (zlib_result == Z_STREAM_END)␊
552␉{␊
553␉␉DBG("Deflated result is %d, in: %d bytes, out: %d bytes, full: %d\n", zlib_result, zstream.total_in, zstream.total_out, full_size);␊
554␉} ␊
555␉else if (zlib_result == Z_OK)␊
556␉{␊
557␉␉/* deflate filled output buffer, meaning the data doesn't compress.␊
558␉␉ */␊
559␉␉DBG("Deflated result is %d, in: %d bytes, out: %d bytes, full: %d\n", zlib_result, zstream.total_in, zstream.total_out, full_size);␊
560␉␉␊
561␉} ␊
562␉else if (zlib_result != Z_STREAM_ERROR)␊
563␉{␊
564␉␉printf("ZLIB Deflate Error: %s\n", zstream.msg);␊
565␉␉getc();␊
566␉}␊
567␉␊
568␉if (zstream_inited) deflateEnd(&zstream);␊
569␉␊
570␉free(executable);␊
571␉␊
572␉return true;␉␊
573␊
574}␊
575␊
576bool patch_bcm_kext(TagPtr plist, char* plistbuffer, void* start)␊
577{␊
578␉TagPtr personality;␊
579␉personality =␉␉XMLCastDict(XMLGetProperty(plist, kPropIOKitPersonalities));␊
580␉personality =␉␉XMLGetProperty(personality, (const char*)"Broadcom 802.11 PCI");␉␊
581␉TagPtr match_names =XMLCastArray(XMLGetProperty(personality, (const char*)"IONameMatch"));␊
582␊
583␉␊
584␉char* new_str = malloc(strlen("pci14e4,xxxx")+1);␊
585␉sprintf(new_str, "pci14e4,%02x", patch_bcm_deviceid);␊
586␊
587␉// Check to see if we *really* need to modify the plist, if not, return false␊
588␉// so that *if* this were going ot be the only modified kext, the repacking code␊
589␉// won't need to be executed.␊
590␉int count = XMLTagCount(match_names);␊
591␉while(count)␊
592␉{␊
593␉␉count--;␊
594␉␉TagPtr replace =␉XMLGetElement(match_names, count);␉// Modify the second entry␊
595␉␉char* orig_string = XMLCastString(replace);␊
596␉␉if(strcmp(orig_string, new_str) == 0) return false;␊
597␉}␊
598␊
599␉␊
600␉TagPtr replace =␉XMLGetElement(match_names, 1);␉// Modify the second entry␊
601␉char* orig_string = XMLCastString(replace);␊
602␉␊
603␉␊
604␉// TODO: verify string doesn't exist first.␊
605␉␊
606␉replace_string(orig_string, new_str, plistbuffer + XMLCastStringOffset(replace), 10240);␊
607␊
608␉return true;␊
609}␊
610␊
611bool patch_gma_kexts(TagPtr plist, char* plistbuffer, void* start)␊
612{␊
613␉int exeutable_offset, full_size, compressed_size;␊
614␉TagPtr personality;␊
615␉long offset;␊
616␉int zlib_result;␊
617␉z_stream zstream;␊
618␉bool zstream_inited = false;␊
619␉mkext2_file_entry* kext;␊
620␉void* compressed_data;␊
621␊
622␉exeutable_offset = XMLCastInteger(XMLGetProperty(plist, kMKEXTExecutableKey));␊
623␉kext = (void*)((char*)start + exeutable_offset);␊
624␊
625␉full_size = MKEXT2_GET_ENTRY_FULLSIZE(kext);␊
626␉compressed_size = MKEXT2_GET_ENTRY_COMPSIZE(kext);␊
627␉compressed_data = MKEXT2_GET_ENTRY_DATA(kext);␊
628␉␊
629␉personality =␉␉XMLCastDict(XMLGetProperty(plist, kPropIOKitPersonalities));␊
630␉if(XMLGetProperty(personality, (const char*)"Intel915"))␊
631␉{␊
632␉␉personality =␉␉XMLGetProperty(personality, (const char*)"Intel915");␊
633␉}␊
634␉else␊
635␉{␊
636␉␉personality =␉␉XMLGetProperty(personality, (const char*)"AppleIntelIntegratedFramebuffer");␉␊
637␉}␊
638#if DEBUG_KEXT_PATCHER␊
639␉char* pcimatch =␉XMLCastString(XMLGetProperty(personality, (const char*)"IOPCIPrimaryMatch"));␊
640#endif␊
641␉offset =␉␉XMLCastStringOffset(XMLGetProperty(personality, (const char*)"IOPCIPrimaryMatch"));␊
642␉␊
643␉char* newstring = malloc(strlen("0x27A28086") + 1);␊
644␉sprintf(newstring, "0x%04x", 0x8086 | (patch_gma_deviceid << 16));␊
645␉␊
646␉DBG("Replacing %s with %s\n", "0x27A28086", newstring); ␊
647␉replace_string("0x27A28086", newstring, plistbuffer + offset, 10240);␊
648␉␊
649␉char* executable = malloc(full_size);␊
650␉␊
651␉bzero(&zstream, sizeof(zstream));␉␉␊
652␉zstream.next_in = (UInt8*)compressed_data;␊
653␉zstream.avail_in = compressed_size;␊
654␉␊
655␉zstream.next_out = (UInt8*)executable;␊
656␉zstream.avail_out = full_size;␊
657␉␊
658␉zstream.zalloc = z_alloc;␊
659␉zstream.zfree = z_free;␊
660␉␊
661␉zlib_result = inflateInit(&zstream);␊
662␉if (Z_OK != zlib_result)␊
663␉{␊
664␉␉printf("ZLIB Inflate Error: %s\n", zstream.msg);␊
665␉␉getc();␊
666␉}␊
667␉else ␊
668␉{␊
669␉␉zstream_inited = true;␊
670␉}␊
671␉␊
672␉␊
673␉zlib_result = inflate(&zstream, Z_FINISH);␊
674␉␊
675␉DBG("Inflated result is %d, in: %d bytes, out: %d bytes, full: %d\n", zlib_result, zstream.total_in, zstream.total_out, full_size);␊
676␉␊
677␉replace_word(0x27A28086, 0x8086 | (patch_gma_deviceid << 16), executable, zstream.total_out);␊
678␉if (zstream_inited) inflateEnd(&zstream);␊
679␉␊
680␉␊
681␉zstream.next_in = (UInt8*)executable;␊
682␉//␉␉zstream.next_out = (UInt8*)((int)compressed_data<<1);␊
683␉zstream.next_out = (UInt8*)compressed_data;␊
684␉␊
685␉zstream.avail_in = full_size;␊
686␉zstream.avail_out = compressed_size;␊
687␉zstream.zalloc = Z_NULL;␊
688␉zstream.zfree = Z_NULL;␊
689␉zstream.opaque = Z_NULL;␊
690␉␊
691␉␊
692␉␊
693␉// Recompress the eecutable␊
694␉zlib_result = deflateInit2(&zstream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,15, 8 /* memLevel */, Z_DEFAULT_STRATEGY);␊
695␉if (Z_OK != zlib_result) {␊
696␉␉printf("ZLIB Deflate Error: %s\n", zstream.msg);␊
697␉␉getc();␊
698␉}␊
699␉else ␊
700␉{␊
701␉␉zstream_inited = true;␊
702␉}␊
703␉␊
704␉zlib_result = deflate(&zstream, Z_FINISH);␊
705␉␊
706␉if (zlib_result == Z_STREAM_END)␊
707␉{␊
708␉␉DBG("Deflated result is %d, in: %d bytes, out: %d bytes, full: %d\n", zlib_result, zstream.total_in, zstream.total_out, full_size);␊
709␉} ␊
710␉else if (zlib_result == Z_OK)␊
711␉{␊
712␉␉/* deflate filled output buffer, meaning the data doesn't compress.␊
713␉␉ */␊
714␉␉DBG("Deflated result is %d, in: %d bytes, out: %d bytes, full: %d\n", zlib_result, zstream.total_in, zstream.total_out, full_size);␊
715␉␉␊
716␉} ␊
717␉else if (zlib_result != Z_STREAM_ERROR)␊
718␉{␊
719␉␉printf("ZLIB Deflate Error: %s\n", zstream.msg);␊
720␉␉getc();␊
721␉}␊
722␉␊
723␉if (zstream_inited) deflateEnd(&zstream);␊
724␉␊
725␉free(executable);␊
726␉␊
727␉return true;␉␊
728}␊
729␊
730int chartohex(char c)␊
731{␊
732␉if(c <= '9' && c >= '0')␊
733␉{␊
734␉␉return c - '0';␉// c is between 0 and 9␊
735␉}␊
736␉else if(c <= 'F' && c >= 'A')␊
737␉{␊
738␉␉return c - 'A' + 10; // c = 10 - 15;␊
739␉}␊
740␉else if(c <= 'f' && c >= 'a')␊
741␉{␊
742␉␉return c - 'a' + 10; // c = 10 - 15;␊
743␉}␊
744␉return 0;␊
745}

Archive Download this file

Revision: 613