#include <mach/kmod.h>
#include <libkern/kernel_mach_header.h>
#include <libkern/prelink.h>
+
+#if CONFIG_EMBEDDED
+extern uuid_t kernelcache_uuid;
+#endif
}
#include <libkern/version.h>
NULL
};
+static int __whereIsAddr(vm_offset_t theAddr, unsigned long * segSizes, vm_offset_t *segAddrs, int segCount );
+
+#define PLK_SEGMENTS 12
+
+static const char * plk_segNames[] = {
+ "__TEXT",
+ "__TEXT_EXEC",
+ "__DATA",
+ "__DATA_CONST",
+ "__LINKEDIT",
+ "__PRELINK_TEXT",
+ "__PLK_TEXT_EXEC",
+ "__PRELINK_DATA",
+ "__PLK_DATA_CONST",
+ "__PLK_LLVM_COV",
+ "__PLK_LINKEDIT",
+ "__PRELINK_INFO",
+ NULL
+};
+
#if PRAGMA_MARK
#pragma mark KLDBootstrap Class
#endif
void readPrelinkedExtensions(
kernel_section_t * prelinkInfoSect);
void readBooterExtensions(void);
- OSReturn readMkextExtensions(
- OSString * deviceTreeName,
- OSData * deviceTreeData);
OSReturn loadKernelComponentKexts(void);
void loadKernelExternalComponents(void);
return;
}
+typedef struct kaslrPackedOffsets {
+ uint32_t count; /* number of offsets */
+ uint32_t offsetsArray[]; /* offsets to slide */
+} kaslrPackedOffsets;
+
/*********************************************************************
*********************************************************************/
void
OSDictionary * prelinkInfoDict = NULL; // do not release
OSString * errorString = NULL; // must release
OSKext * theKernel = NULL; // must release
+#if CONFIG_EMBEDDED
+ OSData * kernelcacheUUID = NULL; // do not release
+#endif
kernel_segment_command_t * prelinkTextSegment = NULL; // see code
kernel_segment_command_t * prelinkInfoSegment = NULL; // see code
bool developerDevice;
bool dontLoad;
#endif
+ OSData * kaslrOffsets = NULL;
+ unsigned long plk_segSizes[PLK_SEGMENTS];
+ vm_offset_t plk_segAddrs[PLK_SEGMENTS];
OSKextLog(/* kext */ NULL,
kOSKextLogProgressLevel |
"Can't find prelinked kexts' text segment.");
goto finish;
}
-
+
#if KASLR_KEXT_DEBUG
unsigned long scratchSize;
vm_offset_t scratchAddr;
prelinkData = (void *) prelinkTextSegment->vmaddr;
prelinkLength = prelinkTextSegment->vmsize;
+ /* build arrays of plk info for later use */
+ const char ** segNamePtr;
+
+ for (segNamePtr = &plk_segNames[0], i = 0; *segNamePtr && i < PLK_SEGMENTS; segNamePtr++, i++) {
+ plk_segSizes[i] = 0;
+ plk_segAddrs[i] = (vm_offset_t)getsegdatafromheader(&_mh_execute_header, *segNamePtr, &plk_segSizes[i]);
+ }
+
/* Unserialize the info dictionary from the prelink info section.
*/
ramDiskBoot = IORamDiskBSDRoot();
#endif /* NO_KEXTD */
+#if CONFIG_EMBEDDED
+ /* Copy in the kernelcache UUID */
+ kernelcacheUUID = OSDynamicCast(OSData,
+ prelinkInfoDict->getObject(kPrelinkInfoKCIDKey));
+ if (!kernelcacheUUID) {
+ bzero(&kernelcache_uuid, sizeof(kernelcache_uuid));
+ } else if (kernelcacheUUID->getLength() != sizeof(kernelcache_uuid)) {
+ panic("kernelcacheUUID length is %d, expected %lu", kernelcacheUUID->getLength(),
+ sizeof(kernelcache_uuid));
+ } else {
+ memcpy((void *)&kernelcache_uuid, (const void *)kernelcacheUUID->getBytesNoCopy(), kernelcacheUUID->getLength());
+ }
+#endif /* CONFIG_EMBEDDED */
+
infoDictArray = OSDynamicCast(OSArray,
prelinkInfoDict->getObject(kPrelinkInfoDictionaryKey));
if (!infoDictArray) {
goto finish;
}
+ /* kaslrOffsets are available use them to slide local relocations */
+ kaslrOffsets = OSDynamicCast(OSData,
+ prelinkInfoDict->getObject(kPrelinkLinkKASLROffsetsKey));
+
/* Create dictionary of excluded kexts
*/
+#ifndef CONFIG_EMBEDDED
OSKext::createExcludeListFromPrelinkInfo(infoDictArray);
-
+#endif
/* Create OSKext objects for each info dictionary.
*/
for (i = 0; i < infoDictArray->getCount(); ++i) {
if (ramDiskOnlyBool == kOSBooleanTrue) {
dontLoad = true;
}
- }
+ }
if (dontLoad == true) {
OSString *bundleID = OSDynamicCast(OSString,
OSNumber *lengthNum = OSDynamicCast(OSNumber,
infoDict->getObject(kPrelinkExecutableSizeKey));
if (addressNum && lengthNum) {
+#if __arm__ || __arm64__
+ vm_offset_t data = (vm_offset_t) ((addressNum->unsigned64BitValue()) + vm_kernel_slide);
+ vm_size_t length = (vm_size_t) (lengthNum->unsigned32BitValue());
+ ml_static_mfree(data, length);
+#else
#error Pick the right way to free prelinked data on this arch
+#endif
}
infoDictArray->removeObject(i--);
* kext system keeps them around until explicitly removed.
* Any creation/registration failures are already logged for us.
*/
- OSKext * newKext = OSKext::withPrelinkedInfoDict(infoDict);
+ OSKext * newKext = OSKext::withPrelinkedInfoDict(infoDict, (kaslrOffsets ? TRUE : FALSE));
OSSafeReleaseNULL(newKext);
}
-
+
+ /* slide kxld relocations */
+ if (kaslrOffsets && vm_kernel_slide > 0) {
+ int slidKextAddrCount = 0;
+ int badSlideAddr = 0;
+ int badSlideTarget = 0;
+
+ const kaslrPackedOffsets * myOffsets = NULL;
+ myOffsets = (const kaslrPackedOffsets *) kaslrOffsets->getBytesNoCopy();
+
+ for (uint32_t j = 0; j < myOffsets->count; j++) {
+
+ uint64_t slideOffset = (uint64_t) myOffsets->offsetsArray[j];
+ uintptr_t * slideAddr = (uintptr_t *) ((uint64_t)prelinkData + slideOffset);
+ int slideAddrSegIndex = -1;
+ int addrToSlideSegIndex = -1;
+
+ slideAddrSegIndex = __whereIsAddr( (vm_offset_t)slideAddr, &plk_segSizes[0], &plk_segAddrs[0], PLK_SEGMENTS );
+ if (slideAddrSegIndex >= 0) {
+ addrToSlideSegIndex = __whereIsAddr( (vm_offset_t)(*slideAddr + vm_kernel_slide), &plk_segSizes[0], &plk_segAddrs[0], PLK_SEGMENTS );
+ if (addrToSlideSegIndex < 0) {
+ badSlideTarget++;
+ continue;
+ }
+ }
+ else {
+ badSlideAddr++;
+ continue;
+ }
+
+ slidKextAddrCount++;
+ *(slideAddr) += vm_kernel_slide;
+ } // for ...
+
+ /* All kexts are now slid, set VM protections for them */
+ OSKext::setAllVMAttributes();
+ }
+
/* Store the number of prelinked kexts in the registry so we can tell
* when the system has been started from a prelinked kernel.
*/
if (prelinkCountObj) {
registryRoot->setProperty(kOSPrelinkKextCountKey, prelinkCountObj);
}
-
+
OSKextLog(/* kext */ NULL,
kOSKextLogProgressLevel |
kOSKextLogGeneralFlag | kOSKextLogKextBookkeepingFlag |
}
finish:
- OSSafeRelease(errorString);
- OSSafeRelease(parsedXML);
- OSSafeRelease(theKernel);
- OSSafeRelease(prelinkCountObj);
+ OSSafeReleaseNULL(errorString);
+ OSSafeReleaseNULL(parsedXML);
+ OSSafeReleaseNULL(theKernel);
+ OSSafeReleaseNULL(prelinkCountObj);
return;
}
+static int __whereIsAddr(vm_offset_t theAddr, unsigned long * segSizes, vm_offset_t *segAddrs, int segCount)
+{
+ int i;
+
+ for (i = 0; i < segCount; i++) {
+ vm_offset_t myAddr = *(segAddrs + i);
+ unsigned long mySize = *(segSizes + i);
+
+ if (theAddr >= myAddr && theAddr < (myAddr + mySize)) {
+ return i;
+ }
+ }
+
+ return -1;
+}
+
+
/*********************************************************************
*********************************************************************/
#define BOOTER_KEXT_PREFIX "Driver-"
-#define BOOTER_MKEXT_PREFIX "DriversPackage-"
typedef struct _DeviceTreeBuffer {
uint32_t paddr;
OSKextLog(/* kext */ NULL,
kOSKextLogProgressLevel |
kOSKextLogDirectoryScanFlag | kOSKextLogKextBookkeepingFlag,
- "Reading startup extensions/mkexts from booter memory.");
+ "Reading startup extensions from booter memory.");
booterMemoryMap = IORegistryEntry::fromPath( "/chosen/memory-map", gIODTPlane);
/* Create dictionary of excluded kexts
*/
+#ifndef CONFIG_EMBEDDED
OSKext::createExcludeListFromBooterData(propertyDict, keyIterator);
+#endif
keyIterator->reset();
while ( ( deviceTreeName =
OSDynamicCast(OSString, keyIterator->getNextObject() ))) {
- boolean_t isMkext = FALSE;
const char * devTreeNameCString = deviceTreeName->getCStringNoCopy();
OSData * deviceTreeEntry = OSDynamicCast(OSData,
propertyDict->getObject(deviceTreeName));
continue;
}
- /* Make sure it is either a kext or an mkext */
- if (!strncmp(devTreeNameCString, BOOTER_KEXT_PREFIX,
- CONST_STRLEN(BOOTER_KEXT_PREFIX))) {
-
- isMkext = FALSE;
-
- } else if (!strncmp(devTreeNameCString, BOOTER_MKEXT_PREFIX,
- CONST_STRLEN(BOOTER_MKEXT_PREFIX))) {
-
- isMkext = TRUE;
-
- } else {
+ /* Make sure it is a kext */
+ if (strncmp(devTreeNameCString,
+ BOOTER_KEXT_PREFIX,
+ CONST_STRLEN(BOOTER_KEXT_PREFIX))) {
continue;
}
OSKextLog(/* kext */ NULL,
kOSKextLogErrorLevel |
kOSKextLogDirectoryScanFlag,
- "Can't get virtual address for device tree mkext entry %s.",
+ "Can't get virtual address for device tree entry %s.",
devTreeNameCString);
goto finish;
}
}
booterData->setDeallocFunction(osdata_phys_free);
- if (isMkext) {
- readMkextExtensions(deviceTreeName, booterData);
- } else {
- /* Create the kext for the entry, then release it, because the
- * kext system keeps them around until explicitly removed.
- * Any creation/registration failures are already logged for us.
- */
- OSKext * newKext = OSKext::withBooterData(deviceTreeName, booterData);
- OSSafeRelease(newKext);
- }
+ /* Create the kext for the entry, then release it, because the
+ * kext system keeps them around until explicitly removed.
+ * Any creation/registration failures are already logged for us.
+ */
+ OSKext * newKext = OSKext::withBooterData(deviceTreeName, booterData);
+ OSSafeReleaseNULL(newKext);
booterMemoryMap->removeProperty(deviceTreeName);
finish:
- OSSafeRelease(booterMemoryMap);
- OSSafeRelease(propertyDict);
- OSSafeRelease(keyIterator);
- OSSafeRelease(booterData);
- OSSafeRelease(aKext);
+ OSSafeReleaseNULL(booterMemoryMap);
+ OSSafeReleaseNULL(propertyDict);
+ OSSafeReleaseNULL(keyIterator);
+ OSSafeReleaseNULL(booterData);
+ OSSafeReleaseNULL(aKext);
return;
}
-/*********************************************************************
-*********************************************************************/
-OSReturn
-KLDBootstrap::readMkextExtensions(
- OSString * deviceTreeName,
- OSData * booterData)
-{
- OSReturn result = kOSReturnError;
-
- uint32_t checksum;
- IORegistryEntry * registryRoot = NULL; // do not release
- OSData * checksumObj = NULL; // must release
-
- OSKextLog(/* kext */ NULL,
- kOSKextLogStepLevel |
- kOSKextLogDirectoryScanFlag | kOSKextLogArchiveFlag,
- "Reading startup mkext archive from device tree entry %s.",
- deviceTreeName->getCStringNoCopy());
-
- /* If we successfully read the archive,
- * then save the mkext's checksum in the IORegistry.
- * assumes we'll only ever have one mkext to boot
- */
- result = OSKext::readMkextArchive(booterData, &checksum);
- if (result == kOSReturnSuccess) {
-
- OSKextLog(/* kext */ NULL,
- kOSKextLogProgressLevel |
- kOSKextLogArchiveFlag,
- "Startup mkext archive has checksum 0x%x.", (int)checksum);
-
- registryRoot = IORegistryEntry::getRegistryRoot();
- assert(registryRoot);
- checksumObj = OSData::withBytes((void *)&checksum, sizeof(checksum));
- assert(checksumObj);
- if (checksumObj) {
- registryRoot->setProperty(kOSStartupMkextCRC, checksumObj);
- }
- }
-
- return result;
-}
-
/*********************************************************************
*********************************************************************/
#define COM_APPLE "com.apple."
}
finish:
- OSSafeRelease(keyIterator);
- OSSafeRelease(extensionsDict);
+ OSSafeReleaseNULL(keyIterator);
+ OSSafeReleaseNULL(extensionsDict);
return;
}
}
}
- OSSafeRelease(theKext);
+ OSSafeReleaseNULL(theKext);
return result;
}
}
finish:
- OSSafeRelease(keyIterator);
- OSSafeRelease(extensionsDict);
+ OSSafeReleaseNULL(keyIterator);
+ OSSafeReleaseNULL(extensionsDict);
return;
}
gIOCatalogue->addDrivers(allPersonalities, false);
finish:
- OSSafeRelease(parsedXML);
- OSSafeRelease(allPersonalities);
- OSSafeRelease(errorString);
- OSSafeRelease(personalitiesIterator);
+ OSSafeReleaseNULL(parsedXML);
+ OSSafeReleaseNULL(allPersonalities);
+ OSSafeReleaseNULL(errorString);
+ OSSafeReleaseNULL(personalitiesIterator);
return;
}
projects / apple / xnu.git / blobdiff