#include <unistd.h>
#include <dirent.h>
#include <sys/errno.h>
#include <sys/fcntl.h>
#include <sys/param.h>
#include <mach/mach.h>
#include <mach/mach_time.h>
#include <mach-o/loader.h>
#include <mach-o/fat.h>
#include <mach/shared_region.h>
#include <assert.h>
#include <CommonCrypto/CommonHMAC.h>
#include <CommonCrypto/CommonDigest.h>
#include <CommonCrypto/CommonDigestSPI.h>
#include <pthread/pthread.h>
#include <string>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include "MachOParser.h"
#include "CodeSigningTypes.h"
#include "DyldSharedCache.h"
#include "CacheBuilder.h"
#include "FileAbstraction.hpp"
#include "LaunchCacheWriter.h"
#include "Trie.hpp"
#include "Diagnostics.h"
#include "ImageProxy.h"
#if __has_include("dyld_cache_config.h")
#include "dyld_cache_config.h"
#else
#define ARM_SHARED_REGION_START 0x1A000000ULL
#define ARM_SHARED_REGION_SIZE 0x26000000ULL
#define ARM64_SHARED_REGION_START 0x180000000ULL
#define ARM64_SHARED_REGION_SIZE 0x40000000ULL
#endif
const CacheBuilder::ArchLayout CacheBuilder::_s_archLayout[] = {
{ 0x7FFF20000000ULL, 0xEFE00000ULL, 0x40000000, 0xFFFF000000000000, "x86_64", 0, 0, 0, 12, true, true },
{ 0x7FFF20000000ULL, 0xEFE00000ULL, 0x40000000, 0xFFFF000000000000, "x86_64h", 0, 0, 0, 12, true, true },
{ SHARED_REGION_BASE_I386, SHARED_REGION_SIZE_I386, 0x00200000, 0x0, "i386", 0, 0, 0, 12, false, false },
{ ARM64_SHARED_REGION_START, ARM64_SHARED_REGION_SIZE, 0x02000000, 0x00FFFF0000000000, "arm64", 0x0000C000, 0x00100000, 0x07F00000, 14, false, true },
{ ARM64_SHARED_REGION_START, ARM64_SHARED_REGION_SIZE, 0x02000000, 0x00FFFF0000000000, "arm64e", 0x0000C000, 0x00100000, 0x07F00000, 14, false, true },
{ ARM_SHARED_REGION_START, ARM_SHARED_REGION_SIZE, 0x02000000, 0xE0000000, "armv7s", 0, 0, 0, 14, false, false },
{ ARM_SHARED_REGION_START, ARM_SHARED_REGION_SIZE, 0x00400000, 0xE0000000, "armv7k", 0, 0, 0, 14, false, false },
{ 0x40000000, 0x40000000, 0x02000000, 0x0, "sim-x86", 0, 0, 0, 14, false, false }
};
const char* const CacheBuilder::_s_neverStubEliminate[] = {
"/usr/lib/system/libdispatch.dylib",
nullptr
};
CacheBuilder::CacheBuilder(const DyldSharedCache::CreateOptions& options)
: _options(options)
, _buffer(nullptr)
, _diagnostics(options.loggingPrefix, options.verbose)
, _archLayout(nullptr)
, _aliasCount(0)
, _slideInfoFileOffset(0)
, _slideInfoBufferSizeAllocated(0)
, _allocatedBufferSize(0)
, _currentFileSize(0)
, _vmSize(0)
, _branchPoolsLinkEditStartAddr(0)
{
std::string targetArch = options.archName;
if ( options.forSimulator && (options.archName == "i386") )
targetArch = "sim-x86";
for (const ArchLayout& layout : _s_archLayout) {
if ( layout.archName == targetArch ) {
_archLayout = &layout;
break;
}
}
}
std::string CacheBuilder::errorMessage()
{
return _diagnostics.errorMessage();
}
const std::set<std::string> CacheBuilder::warnings()
{
return _diagnostics.warnings();
}
const std::set<const mach_header*> CacheBuilder::evictions()
{
return _evictions;
}
void CacheBuilder::deleteBuffer()
{
vm_deallocate(mach_task_self(), (vm_address_t)_buffer, _allocatedBufferSize);
_buffer = nullptr;
_allocatedBufferSize = 0;
}
std::vector<DyldSharedCache::MappedMachO>
CacheBuilder::makeSortedDylibs(const std::vector<DyldSharedCache::MappedMachO>& dylibs, const std::unordered_map<std::string, unsigned> sortOrder)
{
std::vector<DyldSharedCache::MappedMachO> sortedDylibs = dylibs;
std::sort(sortedDylibs.begin(), sortedDylibs.end(), [&](const DyldSharedCache::MappedMachO& a, const DyldSharedCache::MappedMachO& b) {
const auto& orderA = sortOrder.find(a.runtimePath);
const auto& orderB = sortOrder.find(b.runtimePath);
bool foundA = (orderA != sortOrder.end());
bool foundB = (orderB != sortOrder.end());
if ( foundA && foundB )
return orderA->second < orderB->second;
else if ( foundA )
return true;
else if ( foundB )
return false;
else
return a.runtimePath < b.runtimePath;
});
return sortedDylibs;
}
inline uint32_t absolutetime_to_milliseconds(uint64_t abstime)
{
return (uint32_t)(abstime/1000/1000);
}
struct DylibAndSize
{
const char* installName;
uint64_t size;
};
bool CacheBuilder::cacheOverflow(const dyld_cache_mapping_info regions[3])
{
if ( _archLayout->sharedRegionsAreDiscontiguous ) {
return ( (regions[0].size > 0x60000000) || (regions[1].size > 0x40000000) || (regions[2].size > 0x3FE00000) );
}
else {
return (_vmSize > _archLayout->sharedMemorySize);
}
}
void CacheBuilder::build(const std::vector<DyldSharedCache::MappedMachO>& dylibs,
const std::vector<DyldSharedCache::MappedMachO>& otherOsDylibsInput,
const std::vector<DyldSharedCache::MappedMachO>& osExecutables)
{
if ( dylibs.size() < 30 ) {
_diagnostics.error("missing required minimum set of dylibs");
return;
}
uint64_t t1 = mach_absolute_time();
std::vector<DyldSharedCache::MappedMachO> sortedDylibs = makeSortedDylibs(dylibs, _options.dylibOrdering);
std::vector<DyldSharedCache::MappedMachO> otherOsDylibs = otherOsDylibsInput;
dyld_cache_mapping_info regions[3];
SegmentMapping segmentMapping = assignSegmentAddresses(sortedDylibs, regions);
while ( cacheOverflow(regions) ) {
if ( !_options.evictLeafDylibsOnOverflow ) {
_diagnostics.error("cache overflow: %lluMB (max %lluMB)", _vmSize / 1024 / 1024, (_archLayout->sharedMemorySize) / 1024 / 1024);
return;
}
__block std::map<std::string, unsigned int> referenceCount;
for (const DyldSharedCache::MappedMachO& dylib : sortedDylibs) {
dyld3::MachOParser parser(dylib.mh);
parser.forEachDependentDylib(^(const char* loadPath, bool isWeak, bool isReExport, bool isUpward, uint32_t compatVersion, uint32_t curVersion, bool &stop) {
referenceCount[loadPath] += 1;
});
}
std::vector<DylibAndSize> unreferencedDylibs;
for (const DyldSharedCache::MappedMachO& dylib : sortedDylibs) {
dyld3::MachOParser parser(dylib.mh);
const char* installName = parser.installName();
if ( referenceCount.count(installName) == 0 ) {
__block uint64_t segsSize = 0;
parser.forEachSegment(^(const char* segName, uint32_t fileOffset, uint32_t fileSize, uint64_t vmAddr, uint64_t vmSize, uint8_t protections, bool &stop) {
if ( strcmp(segName, "__LINKEDIT") != 0 )
segsSize += vmSize;
});
unreferencedDylibs.push_back({installName, segsSize});
}
}
std::sort(unreferencedDylibs.begin(), unreferencedDylibs.end(), [&](const DylibAndSize& a, const DylibAndSize& b) {
return ( a.size > b.size );
});
uint64_t reductionTarget = _vmSize - _archLayout->sharedMemorySize;
std::set<std::string> toRemove;
for (DylibAndSize& dylib : unreferencedDylibs) {
if ( _options.verbose )
_diagnostics.warning("to prevent cache overflow, not caching %s", dylib.installName);
toRemove.insert(dylib.installName);
if ( dylib.size > reductionTarget )
break;
reductionTarget -= dylib.size;
}
for (const std::string& installName : toRemove) {
for (std::vector<DyldSharedCache::MappedMachO>::iterator it=sortedDylibs.begin(); it != sortedDylibs.end(); ++it) {
dyld3::MachOParser parser(it->mh);
if ( installName == parser.installName() ) {
_evictions.insert(parser.header());
otherOsDylibs.push_back(*it);
sortedDylibs.erase(it);
break;
}
}
}
segmentMapping = assignSegmentAddresses(sortedDylibs, regions);
if ( unreferencedDylibs.size() == 0 && cacheOverflow(regions) ) {
_diagnostics.error("cache overflow, tried evicting %ld leaf daylibs, but still too big: %lluMB (max %lluMB)",
toRemove.size(), _vmSize / 1024 / 1024, (_archLayout->sharedMemorySize) / 1024 / 1024);
return;
}
}
_allocatedBufferSize = std::max(_currentFileSize, (uint64_t)0x100000)*1.1; if ( vm_allocate(mach_task_self(), (vm_address_t*)&_buffer, _allocatedBufferSize, VM_FLAGS_ANYWHERE) != 0 ) {
_diagnostics.error("could not allocate buffer");
return;
}
_currentFileSize = _allocatedBufferSize;
writeCacheHeader(regions, sortedDylibs, segmentMapping);
copyRawSegments(sortedDylibs, segmentMapping);
adjustAllImagesForNewSegmentLocations(sortedDylibs, segmentMapping);
if ( _diagnostics.hasError() )
return;
bindAllImagesInCacheFile(regions);
if ( _diagnostics.hasError() )
return;
if ( _options.optimizeObjC )
optimizeObjC(_buffer, _archLayout->is64, _options.optimizeStubs, _pointersForASLR, _diagnostics);
if ( _diagnostics.hasError() )
return;
std::vector<uint64_t> branchPoolOffsets;
uint64_t cacheStartAddress = _archLayout->sharedMemoryStart;
if ( _options.optimizeStubs ) {
std::vector<uint64_t> branchPoolStartAddrs;
const uint64_t* p = (uint64_t*)((uint8_t*)_buffer + _buffer->header.branchPoolsOffset);
for (int i=0; i < _buffer->header.branchPoolsCount; ++i) {
uint64_t poolAddr = p[i];
branchPoolStartAddrs.push_back(poolAddr);
branchPoolOffsets.push_back(poolAddr - cacheStartAddress);
}
bypassStubs(_buffer, branchPoolStartAddrs, _s_neverStubEliminate, _diagnostics);
}
uint64_t t2 = mach_absolute_time();
fipsSign();
dyld_cache_local_symbols_info* localsInfo = nullptr;
if ( dylibs.size() == 0 )
_currentFileSize = 0x1000;
else
_currentFileSize = optimizeLinkedit(_buffer, _archLayout->is64, _options.excludeLocalSymbols, _options.optimizeStubs, branchPoolOffsets, _diagnostics, &localsInfo);
uint64_t t3 = mach_absolute_time();
__block std::vector<DyldSharedCache::MappedMachO> cachedDylibs;
std::unordered_map<std::string, const DyldSharedCache::MappedMachO*> mapIntoSortedDylibs;
for (const DyldSharedCache::MappedMachO& entry : sortedDylibs) {
mapIntoSortedDylibs[entry.runtimePath] = &entry;
}
_buffer->forEachImage(^(const mach_header* mh, const char* installName) {
auto pos = mapIntoSortedDylibs.find(installName);
if ( pos != mapIntoSortedDylibs.end() ) {
DyldSharedCache::MappedMachO newEntry = *(pos->second);
newEntry.mh = mh;
cachedDylibs.push_back(newEntry);
}
else {
bool found = false;
for (const std::string& prefix : _options.pathPrefixes) {
std::string fullPath = prefix + installName;
char resolvedPath[PATH_MAX];
if ( realpath(fullPath.c_str(), resolvedPath) != nullptr ) {
std::string resolvedUnPrefixed = &resolvedPath[prefix.size()];
pos = mapIntoSortedDylibs.find(resolvedUnPrefixed);
if ( pos != mapIntoSortedDylibs.end() ) {
DyldSharedCache::MappedMachO newEntry = *(pos->second);
newEntry.mh = mh;
cachedDylibs.push_back(newEntry);
found = true;
}
}
}
if ( !found )
fprintf(stderr, "missing mapping for %s\n", installName);
}
});
dyld3::DyldCacheParser dyldCacheParser(_buffer, true);
dyld3::ImageProxyGroup* dylibGroup = dyld3::ImageProxyGroup::makeDyldCacheDylibsGroup(_diagnostics, dyldCacheParser, cachedDylibs,
_options.pathPrefixes, _patchTable,
_options.optimizeStubs, !_options.dylibsRemovedDuringMastering);
if ( _diagnostics.hasError() )
return;
addCachedDylibsImageGroup(dylibGroup);
if ( _diagnostics.hasError() )
return;
uint64_t t4 = mach_absolute_time();
dyld3::ImageProxyGroup* otherGroup = dyld3::ImageProxyGroup::makeOtherOsGroup(_diagnostics, dyldCacheParser, dylibGroup, otherOsDylibs,
_options.inodesAreSameAsRuntime, _options.pathPrefixes);
if ( _diagnostics.hasError() )
return;
addCachedOtherDylibsImageGroup(otherGroup);
if ( _diagnostics.hasError() )
return;
uint64_t t5 = mach_absolute_time();
std::map<std::string, const dyld3::launch_cache::binary_format::Closure*> closures;
for (const DyldSharedCache::MappedMachO& mainProg : osExecutables) {
Diagnostics clsDiag;
const dyld3::launch_cache::binary_format::Closure* cls = dyld3::ImageProxyGroup::makeClosure(clsDiag, dyldCacheParser, dylibGroup, otherGroup, mainProg,
_options.inodesAreSameAsRuntime, _options.pathPrefixes);
if ( clsDiag.hasError() ) {
if ( _options.verbose ) {
_diagnostics.warning("building closure for '%s': %s", mainProg.runtimePath.c_str(), clsDiag.errorMessage().c_str());
for (const std::string& warn : clsDiag.warnings() )
_diagnostics.warning("%s", warn.c_str());
}
}
else {
closures[mainProg.runtimePath] = cls;
}
}
addClosures(closures);
if ( _diagnostics.hasError() )
return;
uint64_t t6 = mach_absolute_time();
if ( _options.cacheSupportsASLR ) {
if ( _archLayout->is64 )
writeSlideInfoV2<Pointer64<LittleEndian>>();
else
writeSlideInfoV2<Pointer32<LittleEndian>>();
}
uint64_t t7 = mach_absolute_time();
dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)_buffer + _buffer->header.mappingOffset);
_currentFileSize = align(_currentFileSize, _archLayout->sharedRegionAlignP2);
mappings[2].size = _currentFileSize - mappings[2].fileOffset;
_buffer->header.sharedRegionStart = _archLayout->sharedMemoryStart;
_buffer->header.sharedRegionSize = _archLayout->sharedMemorySize;
if ( _archLayout->sharedRegionsAreDiscontiguous ) {
uint64_t maxSlide0 = 0x60000000 - mappings[0].size; uint64_t maxSlide1 = 0x40000000 - mappings[1].size;
uint64_t maxSlide2 = 0x3FE00000 - mappings[2].size;
_buffer->header.maxSlide = std::min(std::min(maxSlide0, maxSlide1), maxSlide2);
}
else {
_buffer->header.maxSlide = (_archLayout->sharedMemoryStart + _archLayout->sharedMemorySize) - (mappings[2].address + mappings[2].size);
}
if ( _options.excludeLocalSymbols ) {
size_t localsInfoSize = align(localsInfo->stringsOffset + localsInfo->stringsSize, _archLayout->sharedRegionAlignP2);
if ( _currentFileSize + localsInfoSize > _allocatedBufferSize ) {
_diagnostics.warning("local symbols omitted because cache buffer overflow");
}
else {
memcpy((char*)_buffer+_currentFileSize, localsInfo, localsInfoSize);
_buffer->header.localSymbolsOffset = _currentFileSize;
_buffer->header.localSymbolsSize = localsInfoSize;
_currentFileSize += localsInfoSize;
}
free((void*)localsInfo);
}
recomputeCacheUUID();
__block uint64_t endAddr = 0;
_buffer->forEachRegion(^(const void* content, uint64_t vmAddr, uint64_t size, uint32_t permissions) {
if (vmAddr+size > endAddr)
endAddr = vmAddr+size;
});
_vmSize = endAddr - cacheStartAddress;
if ( _vmSize > _archLayout->sharedMemorySize ) {
_diagnostics.error("cache overflow after optimizations. %lluMB (max %lluMB)", _vmSize / 1024 / 1024, (_archLayout->sharedMemorySize) / 1024 / 1024);
return;
}
codeSign();
if ( _diagnostics.hasError() )
return;
uint64_t t8 = mach_absolute_time();
if ( _options.verbose ) {
fprintf(stderr, "time to copy and bind cached dylibs: %ums\n", absolutetime_to_milliseconds(t2-t1));
fprintf(stderr, "time to optimize LINKEDITs: %ums\n", absolutetime_to_milliseconds(t3-t2));
fprintf(stderr, "time to build ImageGroup of %lu cached dylibs: %ums\n", sortedDylibs.size(), absolutetime_to_milliseconds(t4-t3));
fprintf(stderr, "time to build ImageGroup of %lu other dylibs: %ums\n", otherOsDylibs.size(), absolutetime_to_milliseconds(t5-t4));
fprintf(stderr, "time to build %lu closures: %ums\n", osExecutables.size(), absolutetime_to_milliseconds(t6-t5));
fprintf(stderr, "time to compute slide info: %ums\n", absolutetime_to_milliseconds(t7-t6));
fprintf(stderr, "time to compute UUID and codesign cache file: %ums\n", absolutetime_to_milliseconds(t8-t7));
}
if ( _allocatedBufferSize > _currentFileSize ) {
uint8_t* startOfUnused = (uint8_t*)_buffer+_currentFileSize;
size_t unusedLen = _allocatedBufferSize-_currentFileSize;
vm_deallocate(mach_task_self(), (vm_address_t)startOfUnused, unusedLen);
_allocatedBufferSize = _currentFileSize;
}
return;
}
void CacheBuilder::writeCacheHeader(const dyld_cache_mapping_info regions[3], const std::vector<DyldSharedCache::MappedMachO>& dylibs, const SegmentMapping& segmentMappings)
{
std::string magic = "dyld_v1";
magic.append(15 - magic.length() - _options.archName.length(), ' ');
magic.append(_options.archName);
assert(magic.length() == 15);
memcpy(_buffer->header.magic, magic.c_str(), 16);
_buffer->header.mappingOffset = sizeof(dyld_cache_header);
_buffer->header.mappingCount = 3;
_buffer->header.imagesOffset = (uint32_t)(_buffer->header.mappingOffset + 3*sizeof(dyld_cache_mapping_info) + sizeof(uint64_t)*_branchPoolStarts.size());
_buffer->header.imagesCount = (uint32_t)dylibs.size() + _aliasCount;
_buffer->header.dyldBaseAddress = 0;
_buffer->header.codeSignatureOffset= 0;
_buffer->header.codeSignatureSize = 0;
_buffer->header.slideInfoOffset = _slideInfoFileOffset;
_buffer->header.slideInfoSize = _slideInfoBufferSizeAllocated;
_buffer->header.localSymbolsOffset = 0;
_buffer->header.localSymbolsSize = 0;
_buffer->header.cacheType = _options.optimizeStubs ? kDyldSharedCacheTypeProduction : kDyldSharedCacheTypeDevelopment;
_buffer->header.accelerateInfoAddr = 0;
_buffer->header.accelerateInfoSize = 0;
bzero(_buffer->header.uuid, 16); _buffer->header.branchPoolsOffset = _buffer->header.mappingOffset + 3*sizeof(dyld_cache_mapping_info);
_buffer->header.branchPoolsCount = (uint32_t)_branchPoolStarts.size();
_buffer->header.imagesTextOffset = _buffer->header.imagesOffset + sizeof(dyld_cache_image_info)*_buffer->header.imagesCount;
_buffer->header.imagesTextCount = dylibs.size();
_buffer->header.platform = (uint8_t)_options.platform;
_buffer->header.formatVersion = dyld3::launch_cache::binary_format::kFormatVersion;
_buffer->header.dylibsExpectedOnDisk = !_options.dylibsRemovedDuringMastering;
_buffer->header.simulator = _options.forSimulator;
dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)_buffer + _buffer->header.mappingOffset);
mappings[0] = regions[0];
mappings[1] = regions[1];
mappings[2] = regions[2];
uint64_t* p = (uint64_t*)((char*)_buffer + _buffer->header.branchPoolsOffset);
for (uint64_t pool : _branchPoolStarts) {
*p++ = pool;
}
dyld_cache_image_info* images = (dyld_cache_image_info*)((char*)_buffer + _buffer->header.imagesOffset);
for (const DyldSharedCache::MappedMachO& dylib : dylibs) {
const std::vector<SegmentMappingInfo>& segs = segmentMappings.at(dylib.mh);
dyld3::MachOParser parser(dylib.mh);
const char* installName = parser.installName();
images->address = segs[0].dstCacheAddress;
if ( _options.dylibsRemovedDuringMastering ) {
images->modTime = 0;
images->inode = pathHash(installName);
}
else {
images->modTime = dylib.modTime;
images->inode = dylib.inode;
}
uint32_t installNameOffsetInTEXT = (uint32_t)(installName - (char*)dylib.mh);
images->pathFileOffset = (uint32_t)segs[0].dstCacheOffset + installNameOffsetInTEXT;
++images;
}
dyld_cache_image_text_info* textImages = (dyld_cache_image_text_info*)((char*)_buffer + _buffer->header.imagesTextOffset);
uint32_t stringOffset = (uint32_t)(_buffer->header.imagesTextOffset + sizeof(dyld_cache_image_text_info) * dylibs.size());
for (const DyldSharedCache::MappedMachO& dylib : dylibs) {
const std::vector<SegmentMappingInfo>& segs = segmentMappings.at(dylib.mh);
dyld3::MachOParser parser(dylib.mh);
parser.getUuid(textImages->uuid);
textImages->loadAddress = segs[0].dstCacheAddress;
textImages->textSegmentSize = (uint32_t)segs[0].dstCacheSegmentSize;
textImages->pathOffset = stringOffset;
const char* installName = parser.installName();
::strcpy((char*)_buffer + stringOffset, installName);
stringOffset += (uint32_t)strlen(installName)+1;
++textImages;
}
const dyld_cache_image_info* firstImage = (dyld_cache_image_info*)((char*)_buffer + _buffer->header.imagesOffset);
assert(stringOffset <= (firstImage->address - mappings[0].address));
}
void CacheBuilder::copyRawSegments(const std::vector<DyldSharedCache::MappedMachO>& dylibs, const SegmentMapping& mapping)
{
uint8_t* cacheBytes = (uint8_t*)_buffer;
for (const DyldSharedCache::MappedMachO& dylib : dylibs) {
auto pos = mapping.find(dylib.mh);
assert(pos != mapping.end());
for (const SegmentMappingInfo& info : pos->second) {
::memcpy(&cacheBytes[info.dstCacheOffset], info.srcSegment, info.copySegmentSize);
}
}
}
void CacheBuilder::adjustAllImagesForNewSegmentLocations(const std::vector<DyldSharedCache::MappedMachO>& dylibs, const SegmentMapping& mapping)
{
uint8_t* cacheBytes = (uint8_t*)_buffer;
for (const DyldSharedCache::MappedMachO& dylib : dylibs) {
auto pos = mapping.find(dylib.mh);
assert(pos != mapping.end());
mach_header* mhInCache = (mach_header*)&cacheBytes[pos->second[0].dstCacheOffset];
adjustDylibSegments(_buffer, _archLayout->is64, mhInCache, pos->second, _pointersForASLR, _diagnostics);
if ( _diagnostics.hasError() )
break;
}
}
struct Counts {
unsigned long lazyCount = 0;
unsigned long nonLazyCount = 0;
};
void CacheBuilder::bindAllImagesInCacheFile(const dyld_cache_mapping_info regions[3])
{
const bool log = false;
__block std::unordered_map<std::string, Counts> useCounts;
__block std::unordered_map<std::string, const mach_header*> installNameToMH;
__block std::vector<const mach_header*> dylibMHs;
_buffer->forEachImage(^(const mach_header* mh, const char* installName) {
installNameToMH[installName] = mh;
dylibMHs.push_back(mh);
});
__block Diagnostics parsingDiag;
bool (^dylibFinder)(uint32_t, const char*, void* , const mach_header**, void**) = ^(uint32_t depIndex, const char* depLoadPath, void* extra, const mach_header** foundMH, void** foundExtra) {
auto pos = installNameToMH.find(depLoadPath);
if ( pos != installNameToMH.end() ) {
*foundMH = pos->second;
*foundExtra = nullptr;
return true;
}
parsingDiag.error("dependent dylib %s not found", depLoadPath);
return false;
};
if ( parsingDiag.hasError() ) {
_diagnostics.error("%s", parsingDiag.errorMessage().c_str());
return;
}
for (const mach_header* mh : dylibMHs) {
dyld3::MachOParser parser(mh, true);
bool is64 = parser.is64();
const char* depPaths[256];
const char** depPathsArray = depPaths;
__block int depIndex = 1;
parser.forEachDependentDylib(^(const char* loadPath, bool isWeak, bool isReExport, bool isUpward, uint32_t compatVersion, uint32_t curVersion, bool& stop) {
depPathsArray[depIndex++] = loadPath;
});
uint8_t* segCacheStarts[10];
uint64_t segCacheAddrs[10];
uint8_t** segCacheStartsArray = segCacheStarts;
uint64_t* segCacheAddrsArray = segCacheAddrs;
__block int segIndex = 0;
parser.forEachSegment(^(const char* segName, uint32_t fileOffset, uint32_t fileSize, uint64_t vmAddr, uint64_t vmSize, uint8_t protections, bool& stop) {
segCacheStartsArray[segIndex] = (segIndex == 0) ? (uint8_t*)mh : (uint8_t*)_buffer + fileOffset;
segCacheAddrsArray[segIndex] = vmAddr;
++segIndex;
});
__block Diagnostics bindingDiag;
parser.forEachBind(bindingDiag, ^(uint32_t dataSegIndex, uint64_t dataSegOffset, uint8_t type, int libOrdinal, uint64_t addend, const char* symbolName, bool weakImport, bool lazy, bool& stop) {
if ( log ) {
if ( lazy )
useCounts[symbolName].lazyCount += 1;
else
useCounts[symbolName].nonLazyCount += 1;
}
const mach_header* targetMH = nullptr;
if ( libOrdinal == BIND_SPECIAL_DYLIB_SELF ) {
targetMH = mh;
}
else if ( libOrdinal == BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE ) {
parsingDiag.error("bind ordinal BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE not supported in dylibs in dyld shared cache (found in %s)", parser.installName());
stop = true;
return;
}
else if ( libOrdinal == BIND_SPECIAL_DYLIB_FLAT_LOOKUP ) {
parsingDiag.error("bind ordinal BIND_SPECIAL_DYLIB_FLAT_LOOKUP not supported in dylibs in dyld shared cache (found in %s)", parser.installName());
stop = true;
return;
}
else {
const char* fromPath = depPathsArray[libOrdinal];
auto pos = installNameToMH.find(fromPath);
if (pos == installNameToMH.end()) {
if (!weakImport) {
_diagnostics.error("dependent dylib %s not found", fromPath);
}
return;
}
targetMH = pos->second;
}
dyld3::MachOParser targetParser(targetMH, true);
dyld3::MachOParser::FoundSymbol foundInfo;
uint64_t targetValue = 0;
uint8_t* fixupLoc = segCacheStartsArray[dataSegIndex] + dataSegOffset;
if ( targetParser.findExportedSymbol(parsingDiag, symbolName, nullptr, foundInfo, dylibFinder) ) {
const mach_header* foundInMH = foundInfo.foundInDylib;
dyld3::MachOParser foundInParser(foundInMH, true);
uint64_t foundInBaseAddress = foundInParser.preferredLoadAddress();
switch ( foundInfo.kind ) {
case dyld3::MachOParser::FoundSymbol::Kind::resolverOffset:
case dyld3::MachOParser::FoundSymbol::Kind::headerOffset:
targetValue = foundInBaseAddress + foundInfo.value + addend;
_pointersForASLR.push_back((void*)fixupLoc);
if ( foundInMH != mh ) {
uint32_t mhVmOffset = (uint32_t)((uint8_t*)foundInMH - (uint8_t*)_buffer);
uint32_t definitionCacheVmOffset = (uint32_t)(mhVmOffset + foundInfo.value);
uint32_t referenceCacheDataVmOffset = (uint32_t)(segCacheAddrsArray[dataSegIndex] + dataSegOffset - regions[1].address);
assert(referenceCacheDataVmOffset < (1<<30));
dyld3::launch_cache::binary_format::PatchOffset entry;
entry.last = false;
entry.hasAddend = (addend != 0);
entry.dataRegionOffset = referenceCacheDataVmOffset;
_patchTable[foundInMH][definitionCacheVmOffset].insert(*((uint32_t*)&entry));
}
break;
case dyld3::MachOParser::FoundSymbol::Kind::absolute:
targetValue = foundInfo.value + addend;
break;
}
}
else if ( weakImport ) {
targetValue = 0;
}
else {
parsingDiag.error("cannot find symbol %s, needed in dylib %s", symbolName, parser.installName());
stop = true;
}
switch ( type ) {
case BIND_TYPE_POINTER:
if ( is64 )
*((uint64_t*)fixupLoc) = targetValue;
else
*((uint32_t*)fixupLoc) = (uint32_t)targetValue;
break;
case BIND_TYPE_TEXT_ABSOLUTE32:
case BIND_TYPE_TEXT_PCREL32:
parsingDiag.error("text relocs not supported for shared cache binding in %s", parser.installName());
stop = true;
break;
default:
parsingDiag.error("bad bind type (%d) in %s", type, parser.installName());
stop = true;
break;
}
});
if ( bindingDiag.hasError() ) {
parsingDiag.error("%s in dylib %s", bindingDiag.errorMessage().c_str(), parser.installName());
}
if ( parsingDiag.hasError() )
break;
parser.forEachWeakDef(bindingDiag, ^(bool strongDef, uint32_t dataSegIndex, uint64_t dataSegOffset, uint64_t addend, const char* symbolName, bool &stop) {
if ( strongDef )
return;
uint8_t* fixupLoc = segCacheStartsArray[dataSegIndex] + dataSegOffset;
dyld3::MachOParser::FoundSymbol weakFoundInfo;
Diagnostics weakLookupDiag;
if ( parser.findExportedSymbol(weakLookupDiag, symbolName, nullptr, weakFoundInfo, nullptr) ) {
uint64_t targetValue;
if ( is64 )
targetValue = *((uint64_t*)fixupLoc);
else
targetValue = *((uint32_t*)fixupLoc);
uint32_t definitionCacheVmOffset = (uint32_t)(targetValue - regions[0].address);
uint32_t referenceCacheDataVmOffset = (uint32_t)(segCacheAddrsArray[dataSegIndex] + dataSegOffset - regions[1].address);
assert(referenceCacheDataVmOffset < (1<<30));
dyld3::launch_cache::binary_format::PatchOffset entry;
entry.last = false;
entry.hasAddend = (addend != 0);
entry.dataRegionOffset = referenceCacheDataVmOffset;
_patchTable[mh][definitionCacheVmOffset].insert(*((uint32_t*)&entry));
}
});
if ( bindingDiag.hasError() ) {
parsingDiag.error("%s in dylib %s", bindingDiag.errorMessage().c_str(), parser.installName());
}
if ( parsingDiag.hasError() )
break;
}
if ( log ) {
unsigned lazyCount = 0;
unsigned nonLazyCount = 0;
std::unordered_set<std::string> lazyTargets;
for (auto entry : useCounts) {
fprintf(stderr, "% 3ld % 3ld %s\n", entry.second.lazyCount, entry.second.nonLazyCount, entry.first.c_str());
lazyCount += entry.second.lazyCount;
nonLazyCount += entry.second.nonLazyCount;
if ( entry.second.lazyCount != 0 )
lazyTargets.insert(entry.first);
}
fprintf(stderr, "lazyCount = %d\n", lazyCount);
fprintf(stderr, "nonLazyCount = %d\n", nonLazyCount);
fprintf(stderr, "unique lazys = %ld\n", lazyTargets.size());
}
if ( parsingDiag.hasError() )
_diagnostics.error("%s", parsingDiag.errorMessage().c_str());
}
void CacheBuilder::recomputeCacheUUID(void)
{
uint8_t* uuidLoc = _buffer->header.uuid;
bzero(uuidLoc, 16);
CC_MD5(_buffer, (unsigned)_currentFileSize, uuidLoc);
uuidLoc[6] = ( uuidLoc[6] & 0x0F ) | ( 3 << 4 );
uuidLoc[8] = ( uuidLoc[8] & 0x3F ) | 0x80;
}
CacheBuilder::SegmentMapping CacheBuilder::assignSegmentAddresses(const std::vector<DyldSharedCache::MappedMachO>& dylibs, dyld_cache_mapping_info regions[3])
{
size_t startOffset = sizeof(dyld_cache_header) + 3*sizeof(dyld_cache_mapping_info);
size_t maxPoolCount = 0;
if ( _archLayout->branchReach != 0 )
maxPoolCount = (_archLayout->sharedMemorySize / _archLayout->branchReach);
startOffset += maxPoolCount * sizeof(uint64_t);
startOffset += sizeof(dyld_cache_image_info) * dylibs.size();
startOffset += sizeof(dyld_cache_image_text_info) * dylibs.size();
for (const DyldSharedCache::MappedMachO& dylib : dylibs) {
dyld3::MachOParser parser(dylib.mh);
startOffset += (strlen(parser.installName()) + 1);
}
startOffset = align(startOffset, 12);
_branchPoolStarts.clear();
__block uint64_t addr = _archLayout->sharedMemoryStart;
__block SegmentMapping result;
regions[0].address = addr;
regions[0].fileOffset = 0;
regions[0].initProt = VM_PROT_READ | VM_PROT_EXECUTE;
regions[0].maxProt = VM_PROT_READ | VM_PROT_EXECUTE;
addr += startOffset;
__block uint64_t lastPoolAddress = addr;
for (const DyldSharedCache::MappedMachO& dylib : dylibs) {
dyld3::MachOParser parser(dylib.mh, true);
parser.forEachSegment(^(const char* segName, uint32_t fileOffset, uint32_t fileSize, uint64_t vmAddr, uint64_t vmSize, uint8_t protections, uint32_t segIndex, uint64_t sizeOfSections, uint8_t p2align, bool& stop) {
if ( protections != (VM_PROT_READ | VM_PROT_EXECUTE) )
return;
if ( (_archLayout->branchPoolTextSize != 0) && ((addr + vmSize - lastPoolAddress) > _archLayout->branchReach) ) {
_branchPoolStarts.push_back(addr);
_diagnostics.verbose("adding branch pool at 0x%llX\n", addr);
lastPoolAddress = addr;
addr += _archLayout->branchPoolTextSize;
}
addr = align(addr, std::max(p2align, (uint8_t)12));
SegmentMappingInfo info;
info.srcSegment = (uint8_t*)dylib.mh + fileOffset;
info.segName = segName;
info.dstCacheAddress = addr;
info.dstCacheOffset = (uint32_t)(addr - regions[0].address + regions[0].fileOffset);
info.dstCacheSegmentSize = (uint32_t)align(sizeOfSections, 12);
info.copySegmentSize = (uint32_t)align(sizeOfSections, 12);
info.srcSegmentIndex = segIndex;
result[dylib.mh].push_back(info);
addr += info.dstCacheSegmentSize;
});
}
uint64_t endTextAddress = align(addr, _archLayout->sharedRegionAlignP2);
regions[0].size = endTextAddress - regions[0].address;
if ( _archLayout->sharedRegionsAreDiscontiguous )
addr = _archLayout->sharedMemoryStart + 0x60000000;
else
addr = align((addr + _archLayout->sharedRegionPadding), _archLayout->sharedRegionAlignP2);
regions[1].address = addr;
regions[1].fileOffset = regions[0].fileOffset + regions[0].size;
regions[1].initProt = VM_PROT_READ | VM_PROT_WRITE;
regions[1].maxProt = VM_PROT_READ | VM_PROT_WRITE;
__block int dataConstSegmentCount = 0;
for (const DyldSharedCache::MappedMachO& dylib : dylibs) {
dyld3::MachOParser parser(dylib.mh, true);
parser.forEachSegment(^(const char* segName, uint32_t fileOffset, uint32_t fileSize, uint64_t vmAddr, uint64_t vmSize, uint8_t protections, uint32_t segIndex, uint64_t sizeOfSections, uint8_t p2align, bool& stop) {
if ( protections != (VM_PROT_READ | VM_PROT_WRITE) )
return;
if ( strcmp(segName, "__DATA_CONST") != 0 )
return;
++dataConstSegmentCount;
addr = align(addr, p2align);
size_t copySize = std::min((size_t)fileSize, (size_t)sizeOfSections);
SegmentMappingInfo info;
info.srcSegment = (uint8_t*)dylib.mh + fileOffset;
info.segName = segName;
info.dstCacheAddress = addr;
info.dstCacheOffset = (uint32_t)(addr - regions[1].address + regions[1].fileOffset);
info.dstCacheSegmentSize = (uint32_t)sizeOfSections;
info.copySegmentSize = (uint32_t)copySize;
info.srcSegmentIndex = segIndex;
result[dylib.mh].push_back(info);
addr += info.dstCacheSegmentSize;
});
}
for (const DyldSharedCache::MappedMachO& dylib : dylibs) {
dyld3::MachOParser parser(dylib.mh, true);
parser.forEachSegment(^(const char* segName, uint32_t fileOffset, uint32_t fileSize, uint64_t vmAddr, uint64_t vmSize, uint8_t protections, uint32_t segIndex, uint64_t sizeOfSections, uint8_t p2align, bool& stop) {
if ( protections != (VM_PROT_READ | VM_PROT_WRITE) )
return;
if ( strcmp(segName, "__DATA_CONST") == 0 )
return;
if ( strcmp(segName, "__DATA_DIRTY") == 0 )
return;
if ( dataConstSegmentCount > 10 ) {
addr = align(addr, p2align);
}
else {
addr = align(addr, std::max(p2align, (uint8_t)12));
}
size_t copySize = std::min((size_t)fileSize, (size_t)sizeOfSections);
SegmentMappingInfo info;
info.srcSegment = (uint8_t*)dylib.mh + fileOffset;
info.segName = segName;
info.dstCacheAddress = addr;
info.dstCacheOffset = (uint32_t)(addr - regions[1].address + regions[1].fileOffset);
info.dstCacheSegmentSize = (uint32_t)sizeOfSections;
info.copySegmentSize = (uint32_t)copySize;
info.srcSegmentIndex = segIndex;
result[dylib.mh].push_back(info);
addr += info.dstCacheSegmentSize;
});
}
addr = align(addr, 12);
std::vector<DyldSharedCache::MappedMachO> dirtyDataDylibs = makeSortedDylibs(dylibs, _options.dirtyDataSegmentOrdering);
for (const DyldSharedCache::MappedMachO& dylib : dirtyDataDylibs) {
dyld3::MachOParser parser(dylib.mh, true);
parser.forEachSegment(^(const char* segName, uint32_t fileOffset, uint32_t fileSize, uint64_t vmAddr, uint64_t vmSize, uint8_t protections, uint32_t segIndex, uint64_t sizeOfSections, uint8_t p2align, bool& stop) {
if ( protections != (VM_PROT_READ | VM_PROT_WRITE) )
return;
if ( strcmp(segName, "__DATA_DIRTY") != 0 )
return;
addr = align(addr, p2align);
size_t copySize = std::min((size_t)fileSize, (size_t)sizeOfSections);
SegmentMappingInfo info;
info.srcSegment = (uint8_t*)dylib.mh + fileOffset;
info.segName = segName;
info.dstCacheAddress = addr;
info.dstCacheOffset = (uint32_t)(addr - regions[1].address + regions[1].fileOffset);
info.dstCacheSegmentSize = (uint32_t)sizeOfSections;
info.copySegmentSize = (uint32_t)copySize;
info.srcSegmentIndex = segIndex;
result[dylib.mh].push_back(info);
addr += info.dstCacheSegmentSize;
});
}
uint64_t endDataAddress = align(addr, _archLayout->sharedRegionAlignP2);
regions[1].size = endDataAddress - regions[1].address;
if ( _archLayout->sharedRegionsAreDiscontiguous )
addr = _archLayout->sharedMemoryStart + 0xA0000000;
else
addr = align((addr + _archLayout->sharedRegionPadding), _archLayout->sharedRegionAlignP2);
regions[2].address = addr;
regions[2].fileOffset = regions[1].fileOffset + regions[1].size;
regions[2].maxProt = VM_PROT_READ;
regions[2].initProt = VM_PROT_READ;
if ( _options.cacheSupportsASLR ) {
_slideInfoBufferSizeAllocated = align((regions[1].size/4096) * 4, _archLayout->sharedRegionAlignP2); _slideInfoFileOffset = regions[2].fileOffset;
addr += _slideInfoBufferSizeAllocated;
}
for (const DyldSharedCache::MappedMachO& dylib : dylibs) {
dyld3::MachOParser parser(dylib.mh, true);
parser.forEachSegment(^(const char* segName, uint32_t fileOffset, uint32_t fileSize, uint64_t vmAddr, uint64_t vmSize, uint8_t protections, uint32_t segIndex, uint64_t sizeOfSections, uint8_t p2align, bool& stop) {
if ( protections != VM_PROT_READ )
return;
if ( strcmp(segName, "__LINKEDIT") == 0 )
return;
addr = align(addr, std::max(p2align, (uint8_t)12));
SegmentMappingInfo info;
info.srcSegment = (uint8_t*)dylib.mh + fileOffset;
info.segName = segName;
info.dstCacheAddress = addr;
info.dstCacheOffset = (uint32_t)(addr - regions[2].address + regions[2].fileOffset);
info.dstCacheSegmentSize = (uint32_t)align(sizeOfSections, 12);
info.copySegmentSize = (uint32_t)sizeOfSections;
info.srcSegmentIndex = segIndex;
result[dylib.mh].push_back(info);
addr += info.dstCacheSegmentSize;
});
}
for (const DyldSharedCache::MappedMachO& dylib : dylibs) {
dyld3::MachOParser parser(dylib.mh, true);
parser.forEachSegment(^(const char* segName, uint32_t fileOffset, uint32_t fileSize, uint64_t vmAddr, uint64_t vmSize, uint8_t protections, uint32_t segIndex, uint64_t sizeOfSections, uint8_t p2align, bool& stop) {
if ( protections != VM_PROT_READ )
return;
if ( strcmp(segName, "__LINKEDIT") != 0 )
return;
addr = align(addr, std::max(p2align, (uint8_t)12));
SegmentMappingInfo info;
info.srcSegment = (uint8_t*)dylib.mh + fileOffset;
info.segName = segName;
info.dstCacheAddress = addr;
info.dstCacheOffset = (uint32_t)(addr - regions[2].address + regions[2].fileOffset);
info.dstCacheSegmentSize = (uint32_t)align(sizeOfSections, 12);
info.copySegmentSize = (uint32_t)align(fileSize, 12);
info.srcSegmentIndex = segIndex;
result[dylib.mh].push_back(info);
addr += info.dstCacheSegmentSize;
});
}
_branchPoolsLinkEditStartAddr = addr;
addr += (_branchPoolStarts.size() * _archLayout->branchPoolLinkEditSize);
uint64_t endReadOnlyAddress = align(addr, _archLayout->sharedRegionAlignP2);
regions[2].size = endReadOnlyAddress - regions[2].address;
_currentFileSize = regions[2].fileOffset + regions[2].size;
if ( _options.excludeLocalSymbols ) {
_vmSize = regions[2].address + (regions[2].size * 2 / 5) - regions[0].address;
}
else {
_vmSize = regions[2].address + (regions[2].size * 9 / 10) - regions[0].address;
}
for (auto& entry : result) {
std::vector<SegmentMappingInfo>& infos = entry.second;
std::sort(infos.begin(), infos.end(), [&](const SegmentMappingInfo& a, const SegmentMappingInfo& b) {
return a.srcSegmentIndex < b.srcSegmentIndex;
});
}
return result;
}
uint64_t CacheBuilder::pathHash(const char* path)
{
uint64_t sum = 0;
for (const char* s=path; *s != '\0'; ++s)
sum += sum*4 + *s;
return sum;
}
void CacheBuilder::findDylibAndSegment(const void* contentPtr, std::string& foundDylibName, std::string& foundSegName)
{
foundDylibName = "???";
foundSegName = "???";
uint32_t cacheOffset = (uint32_t)((uint8_t*)contentPtr - (uint8_t*)_buffer);
_buffer->forEachImage(^(const mach_header* mh, const char* installName) {
dyld3::MachOParser parser(mh, true);
parser.forEachSegment(^(const char* segName, uint32_t fileOffset, uint32_t fileSize, uint64_t vmAddr, uint64_t vmSize, uint8_t protections, bool& stop) {
if ( (cacheOffset > fileOffset) && (cacheOffset < (fileOffset+vmSize)) ) {
foundDylibName = installName;
foundSegName = segName;
}
});
});
}
template <typename P>
bool CacheBuilder::makeRebaseChain(uint8_t* pageContent, uint16_t lastLocationOffset, uint16_t offset, const dyld_cache_slide_info2* info)
{
typedef typename P::uint_t pint_t;
const pint_t deltaMask = (pint_t)(info->delta_mask);
const pint_t valueMask = ~deltaMask;
const pint_t valueAdd = (pint_t)(info->value_add);
const unsigned deltaShift = __builtin_ctzll(deltaMask) - 2;
const uint32_t maxDelta = (uint32_t)(deltaMask >> deltaShift);
pint_t* lastLoc = (pint_t*)&pageContent[lastLocationOffset+0];
pint_t lastValue = (pint_t)P::getP(*lastLoc);
if ( (lastValue - valueAdd) & deltaMask ) {
std::string dylibName;
std::string segName;
findDylibAndSegment((void*)pageContent, dylibName, segName);
_diagnostics.error("rebase pointer does not point within cache. lastOffset=0x%04X, seg=%s, dylib=%s\n",
lastLocationOffset, segName.c_str(), dylibName.c_str());
return false;
}
if ( offset <= (lastLocationOffset+maxDelta) ) {
pint_t delta = offset - lastLocationOffset;
pint_t newLastValue = ((lastValue - valueAdd) & valueMask) | (delta << deltaShift);
P::setP(*lastLoc, newLastValue);
return true;
}
uint16_t nonRebaseLocationOffsets[1024];
unsigned nrIndex = 0;
for (uint16_t i = lastLocationOffset; i < offset-maxDelta; ) {
nonRebaseLocationOffsets[nrIndex] = 0;
for (int j=maxDelta; j > 0; j -= 4) {
pint_t value = (pint_t)P::getP(*(pint_t*)&pageContent[i+j]);
if ( value == 0 ) {
nonRebaseLocationOffsets[nrIndex] = i+j;
break;
}
}
if ( nonRebaseLocationOffsets[nrIndex] == 0 ) {
lastValue = (pint_t)P::getP(*lastLoc);
pint_t newValue = ((lastValue - valueAdd) & valueMask);
P::setP(*lastLoc, newValue);
return false;
}
i = nonRebaseLocationOffsets[nrIndex];
++nrIndex;
}
uint16_t prevOffset = lastLocationOffset;
pint_t* prevLoc = (pint_t*)&pageContent[prevOffset];
for (int n=0; n < nrIndex; ++n) {
uint16_t nOffset = nonRebaseLocationOffsets[n];
assert(nOffset != 0);
pint_t* nLoc = (pint_t*)&pageContent[nOffset];
uint32_t delta2 = nOffset - prevOffset;
pint_t value = (pint_t)P::getP(*prevLoc);
pint_t newValue;
if ( value == 0 )
newValue = (delta2 << deltaShift);
else
newValue = ((value - valueAdd) & valueMask) | (delta2 << deltaShift);
P::setP(*prevLoc, newValue);
prevOffset = nOffset;
prevLoc = nLoc;
}
uint32_t delta3 = offset - prevOffset;
pint_t value = (pint_t)P::getP(*prevLoc);
pint_t newValue;
if ( value == 0 )
newValue = (delta3 << deltaShift);
else
newValue = ((value - valueAdd) & valueMask) | (delta3 << deltaShift);
P::setP(*prevLoc, newValue);
return true;
}
template <typename P>
void CacheBuilder::addPageStarts(uint8_t* pageContent, const bool bitmap[], const dyld_cache_slide_info2* info,
std::vector<uint16_t>& pageStarts, std::vector<uint16_t>& pageExtras)
{
typedef typename P::uint_t pint_t;
const pint_t deltaMask = (pint_t)(info->delta_mask);
const pint_t valueMask = ~deltaMask;
const uint32_t pageSize = info->page_size;
const pint_t valueAdd = (pint_t)(info->value_add);
uint16_t startValue = DYLD_CACHE_SLIDE_PAGE_ATTR_NO_REBASE;
uint16_t lastLocationOffset = 0xFFFF;
for(int i=0; i < pageSize/4; ++i) {
unsigned offset = i*4;
if ( bitmap[i] ) {
if ( startValue == DYLD_CACHE_SLIDE_PAGE_ATTR_NO_REBASE ) {
startValue = i;
}
else if ( !makeRebaseChain<P>(pageContent, lastLocationOffset, offset, info) ) {
if ( (startValue & DYLD_CACHE_SLIDE_PAGE_ATTR_EXTRA) == 0 ) {
unsigned indexInExtras = (unsigned)pageExtras.size();
if ( indexInExtras > 0x3FFF ) {
_diagnostics.error("rebase overflow in page extras");
return;
}
pageExtras.push_back(startValue);
startValue = indexInExtras | DYLD_CACHE_SLIDE_PAGE_ATTR_EXTRA;
}
pageExtras.push_back(i);
}
lastLocationOffset = offset;
}
}
if ( lastLocationOffset != 0xFFFF ) {
pint_t* lastLoc = (pint_t*)&pageContent[lastLocationOffset];
pint_t lastValue = (pint_t)P::getP(*lastLoc);
pint_t newValue = ((lastValue - valueAdd) & valueMask);
P::setP(*lastLoc, newValue);
}
if ( startValue & DYLD_CACHE_SLIDE_PAGE_ATTR_EXTRA ) {
pageExtras.back() |= DYLD_CACHE_SLIDE_PAGE_ATTR_END;
}
pageStarts.push_back(startValue);
}
template <typename P>
void CacheBuilder::writeSlideInfoV2()
{
typedef typename P::uint_t pint_t;
typedef typename P::E E;
const uint32_t pageSize = 4096;
const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)_buffer + _buffer->header.mappingOffset);
uint8_t* const dataStart = (uint8_t*)_buffer + mappings[1].fileOffset;
uint8_t* const dataEnd = dataStart + mappings[1].size;
unsigned pageCount = (unsigned)(mappings[1].size+pageSize-1)/pageSize;
const long bitmapSize = pageCount*(pageSize/4)*sizeof(bool);
bool* bitmap = (bool*)calloc(bitmapSize, 1);
for (void* p : _pointersForASLR) {
if ( (p < dataStart) || ( p > dataEnd) ) {
_diagnostics.error("DATA pointer for sliding, out of range\n");
free(bitmap);
return;
}
long byteOffset = (long)((uint8_t*)p - dataStart);
if ( (byteOffset % 4) != 0 ) {
_diagnostics.error("pointer not 4-byte aligned in DATA offset 0x%08lX\n", byteOffset);
free(bitmap);
return;
}
long boolIndex = byteOffset / 4;
if ( *((pint_t*)p) == 0 ) {
std::string dylibName;
std::string segName;
findDylibAndSegment(p, dylibName, segName);
_diagnostics.warning("NULL pointer asked to be slid in %s at DATA region offset 0x%04lX of %s", segName.c_str(), byteOffset, dylibName.c_str());
continue;
}
bitmap[boolIndex] = true;
}
assert(_slideInfoFileOffset != 0);
dyld_cache_slide_info2* info = (dyld_cache_slide_info2*)((uint8_t*)_buffer + _slideInfoFileOffset);
info->version = 2;
info->page_size = pageSize;
info->delta_mask = _archLayout->pointerDeltaMask;
info->value_add = (sizeof(pint_t) == 8) ? 0 : _archLayout->sharedMemoryStart;
std::vector<uint16_t> pageStarts;
std::vector<uint16_t> pageExtras;
pageStarts.reserve(pageCount);
uint8_t* pageContent = dataStart;;
const bool* bitmapForPage = bitmap;
for (unsigned i=0; i < pageCount; ++i) {
addPageStarts<P>(pageContent, bitmapForPage, info, pageStarts, pageExtras);
if ( _diagnostics.hasError() ) {
free(bitmap);
return;
}
pageContent += pageSize;
bitmapForPage += (sizeof(bool)*(pageSize/4));
}
free((void*)bitmap);
info->page_starts_offset = sizeof(dyld_cache_slide_info2);
info->page_starts_count = (unsigned)pageStarts.size();
info->page_extras_offset = (unsigned)(sizeof(dyld_cache_slide_info2)+pageStarts.size()*sizeof(uint16_t));
info->page_extras_count = (unsigned)pageExtras.size();
uint16_t* pageStartsBuffer = (uint16_t*)((char*)info + info->page_starts_offset);
uint16_t* pageExtrasBuffer = (uint16_t*)((char*)info + info->page_extras_offset);
for (unsigned i=0; i < pageStarts.size(); ++i)
pageStartsBuffer[i] = pageStarts[i];
for (unsigned i=0; i < pageExtras.size(); ++i)
pageExtrasBuffer[i] = pageExtras[i];
_buffer->header.slideInfoSize = align(info->page_extras_offset + pageExtras.size()*sizeof(uint16_t), _archLayout->sharedRegionAlignP2);
if ( _buffer->header.slideInfoSize > _slideInfoBufferSizeAllocated ) {
_diagnostics.error("kernel slide info overflow buffer");
}
}
void CacheBuilder::fipsSign() {
__block bool found = false;
_buffer->forEachImage(^(const mach_header* mh, const char* installName) {
__block void *hash_location = nullptr;
if (strcmp(installName, "/usr/lib/system/libcorecrypto.dylib") != 0) {
return;
}
found = true;
auto parser = dyld3::MachOParser(mh, true);
parser.forEachLocalSymbol(_diagnostics, ^(const char *symbolName, uint64_t n_value, uint8_t n_type, uint8_t n_sect, uint16_t n_desc, bool &stop) {
if (strcmp(symbolName, "_fipspost_precalc_hmac") != 0)
return;
hash_location = (void *)(n_value - _archLayout->sharedMemoryStart + (uintptr_t)_buffer);
stop = true;
});
if (hash_location == nullptr) {
_diagnostics.warning("Could not find _fipspost_precalc_hmac, skipping FIPS sealing");
return;
}
parser.forEachSection(^(const char *segName, const char *sectionName, uint32_t flags, const void *content, size_t size, bool illegalSectionSize, bool &stop) {
if ( (strcmp(segName, "__TEXT" ) != 0) || (strcmp(sectionName, "__text") != 0) ) {
return;
}
if (illegalSectionSize) {
_diagnostics.error("FIPS section %s/%s extends beyond the end of the segment", segName, sectionName);
return;
}
unsigned char hmac_key = 0;
CCHmac(kCCHmacAlgSHA256, &hmac_key, 1, content, size, hash_location);
stop = true;
});
});
if (!found) {
_diagnostics.warning("Could not find /usr/lib/system/libcorecrypto.dylib, skipping FIPS sealing");
}
}
void CacheBuilder::codeSign()
{
uint8_t dscHashType;
uint8_t dscHashSize;
uint32_t dscDigestFormat;
bool agile = false;
switch (_options.codeSigningDigestMode) {
case DyldSharedCache::Agile:
agile = true;
case DyldSharedCache::SHA1only:
dscHashType = CS_HASHTYPE_SHA1;
dscHashSize = CS_HASH_SIZE_SHA1;
dscDigestFormat = kCCDigestSHA1;
break;
case DyldSharedCache::SHA256only:
dscHashType = CS_HASHTYPE_SHA256;
dscHashSize = CS_HASH_SIZE_SHA256;
dscDigestFormat = kCCDigestSHA256;
break;
default:
_diagnostics.error("codeSigningDigestMode has unknown, unexpected value %d, bailing out.",
_options.codeSigningDigestMode);
return;
}
std::string cacheIdentifier = "com.apple.dyld.cache." + _options.archName;
if ( _options.dylibsRemovedDuringMastering ) {
if ( _options.optimizeStubs )
cacheIdentifier = "com.apple.dyld.cache." + _options.archName + ".release";
else
cacheIdentifier = "com.apple.dyld.cache." + _options.archName + ".development";
}
size_t inBbufferSize = _currentFileSize;
const uint8_t* inBuffer = (uint8_t*)_buffer;
uint8_t* csBuffer = (uint8_t*)_buffer+inBbufferSize;
uint32_t blobCount = agile ? 4 : 3;
size_t idSize = cacheIdentifier.size()+1; uint32_t slotCount = (uint32_t)((inBbufferSize + CS_PAGE_SIZE - 1) / CS_PAGE_SIZE);
uint32_t xSlotCount = CSSLOT_REQUIREMENTS;
size_t idOffset = offsetof(CS_CodeDirectory, end_withExecSeg);
size_t hashOffset = idOffset+idSize + dscHashSize*xSlotCount;
size_t hash256Offset = idOffset+idSize + CS_HASH_SIZE_SHA256*xSlotCount;
size_t cdSize = hashOffset + (slotCount * dscHashSize);
size_t cd256Size = agile ? hash256Offset + (slotCount * CS_HASH_SIZE_SHA256) : 0;
size_t reqsSize = 12;
size_t cmsSize = sizeof(CS_Blob);
size_t cdOffset = sizeof(CS_SuperBlob) + blobCount*sizeof(CS_BlobIndex);
size_t cd256Offset = cdOffset + cdSize;
size_t reqsOffset = cd256Offset + cd256Size; size_t cmsOffset = reqsOffset + reqsSize;
size_t sbSize = cmsOffset + cmsSize;
size_t sigSize = align(sbSize, 14);
if ( _currentFileSize+sigSize > _allocatedBufferSize ) {
_diagnostics.error("cache buffer too small to hold code signature (buffer size=%lldMB, signature size=%ldMB, free space=%lldMB)",
_allocatedBufferSize/1024/1024, sigSize/1024/1024, (_allocatedBufferSize-_currentFileSize)/1024/1024);
return;
}
CS_SuperBlob* sb = reinterpret_cast<CS_SuperBlob*>(csBuffer);
sb->magic = htonl(CSMAGIC_EMBEDDED_SIGNATURE);
sb->length = htonl(sbSize);
sb->count = htonl(blobCount);
sb->index[0].type = htonl(CSSLOT_CODEDIRECTORY);
sb->index[0].offset = htonl(cdOffset);
sb->index[1].type = htonl(CSSLOT_REQUIREMENTS);
sb->index[1].offset = htonl(reqsOffset);
sb->index[2].type = htonl(CSSLOT_CMS_SIGNATURE);
sb->index[2].offset = htonl(cmsOffset);
if ( agile ) {
sb->index[3].type = htonl(CSSLOT_ALTERNATE_CODEDIRECTORIES + 0);
sb->index[3].offset = htonl(cd256Offset);
}
CS_RequirementsBlob* reqs = (CS_RequirementsBlob*)(((char*)sb)+reqsOffset);
reqs->magic = htonl(CSMAGIC_REQUIREMENTS);
reqs->length = htonl(sizeof(CS_RequirementsBlob));
reqs->data = 0;
CS_CodeDirectory* cd = (CS_CodeDirectory*)(((char*)sb)+cdOffset);
cd->magic = htonl(CSMAGIC_CODEDIRECTORY);
cd->length = htonl(cdSize);
cd->version = htonl(0x20400); cd->flags = htonl(kSecCodeSignatureAdhoc);
cd->hashOffset = htonl(hashOffset);
cd->identOffset = htonl(idOffset);
cd->nSpecialSlots = htonl(xSlotCount);
cd->nCodeSlots = htonl(slotCount);
cd->codeLimit = htonl(inBbufferSize);
cd->hashSize = dscHashSize;
cd->hashType = dscHashType;
cd->platform = 0; cd->pageSize = __builtin_ctz(CS_PAGE_SIZE); cd->spare2 = 0; cd->scatterOffset = 0; cd->teamOffset = 0; cd->spare3 = 0; cd->codeLimit64 = 0;
const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)_buffer + _buffer->header.mappingOffset);
cd->execSegBase = htonll(mappings[0].fileOffset); cd->execSegLimit = htonll(mappings[0].size); cd->execSegFlags = 0;
strcpy((char*)cd + idOffset, cacheIdentifier.c_str());
uint8_t* hashSlot = (uint8_t*)cd + hashOffset;
uint8_t* reqsHashSlot = &hashSlot[-CSSLOT_REQUIREMENTS*dscHashSize];
CCDigest(dscDigestFormat, (uint8_t*)reqs, sizeof(CS_RequirementsBlob), reqsHashSlot);
CS_CodeDirectory* cd256;
uint8_t* hash256Slot;
uint8_t* reqsHash256Slot;
if ( agile ) {
cd256 = (CS_CodeDirectory*)(((char*)sb)+cd256Offset);
cd256->magic = htonl(CSMAGIC_CODEDIRECTORY);
cd256->length = htonl(cd256Size);
cd256->version = htonl(0x20400); cd256->flags = htonl(kSecCodeSignatureAdhoc);
cd256->hashOffset = htonl(hash256Offset);
cd256->identOffset = htonl(idOffset);
cd256->nSpecialSlots = htonl(xSlotCount);
cd256->nCodeSlots = htonl(slotCount);
cd256->codeLimit = htonl(inBbufferSize);
cd256->hashSize = CS_HASH_SIZE_SHA256;
cd256->hashType = CS_HASHTYPE_SHA256;
cd256->platform = 0; cd256->pageSize = __builtin_ctz(CS_PAGE_SIZE); cd256->spare2 = 0; cd256->scatterOffset = 0; cd256->teamOffset = 0; cd256->spare3 = 0; cd256->codeLimit64 = 0;
cd256->execSegBase = cd->execSegBase;
cd256->execSegLimit = cd->execSegLimit;
cd256->execSegFlags = cd->execSegFlags;
strcpy((char*)cd256 + idOffset, cacheIdentifier.c_str());
hash256Slot = (uint8_t*)cd256 + hash256Offset;
reqsHash256Slot = &hash256Slot[-CSSLOT_REQUIREMENTS*CS_HASH_SIZE_SHA256];
CCDigest(kCCDigestSHA256, (uint8_t*)reqs, sizeof(CS_RequirementsBlob), reqsHash256Slot);
}
else {
cd256 = NULL;
hash256Slot = NULL;
reqsHash256Slot = NULL;
}
CS_Blob* cms = (CS_Blob*)(((char*)sb)+cmsOffset);
cms->magic = htonl(CSMAGIC_BLOBWRAPPER);
cms->length = htonl(sizeof(CS_Blob));
_buffer->header.codeSignatureOffset = inBbufferSize;
_buffer->header.codeSignatureSize = sigSize;
const uint8_t* code = inBuffer;
for (uint32_t i=0; i < slotCount; ++i) {
CCDigest(dscDigestFormat, code, CS_PAGE_SIZE, hashSlot);
hashSlot += dscHashSize;
if ( agile ) {
CCDigest(kCCDigestSHA256, code, CS_PAGE_SIZE, hash256Slot);
hash256Slot += CS_HASH_SIZE_SHA256;
}
code += CS_PAGE_SIZE;
}
uint8_t fullCdHash[dscHashSize];
CCDigest(dscDigestFormat, (const uint8_t*)cd, cdSize, fullCdHash);
memcpy(_cdHashFirst, fullCdHash, 20);
if ( agile ) {
uint8_t fullCdHash256[CS_HASH_SIZE_SHA256];
CCDigest(kCCDigestSHA256, (const uint8_t*)cd256, cd256Size, fullCdHash256);
memcpy(_cdHashSecond, fullCdHash256, 20);
}
else {
memset(_cdHashSecond, 0, 20);
}
_currentFileSize += sigSize;
}
const bool CacheBuilder::agileSignature()
{
return _options.codeSigningDigestMode == DyldSharedCache::Agile;
}
static const std::string cdHash(uint8_t hash[20])
{
char buff[48];
for (int i = 0; i < 20; ++i)
sprintf(&buff[2*i], "%2.2x", hash[i]);
return buff;
}
const std::string CacheBuilder::cdHashFirst()
{
return cdHash(_cdHashFirst);
}
const std::string CacheBuilder::cdHashSecond()
{
return cdHash(_cdHashSecond);
}
void CacheBuilder::addCachedDylibsImageGroup(dyld3::ImageProxyGroup* dylibGroup)
{
const dyld3::launch_cache::binary_format::ImageGroup* groupBinary = dylibGroup->makeImageGroupBinary(_diagnostics, _s_neverStubEliminate);
if (!groupBinary)
return;
dyld3::launch_cache::ImageGroup group(groupBinary);
size_t groupSize = group.size();
if ( _currentFileSize+groupSize > _allocatedBufferSize ) {
_diagnostics.error("cache buffer too small to hold group[0] info (buffer size=%lldMB, group size=%ldMB, free space=%lldMB)",
_allocatedBufferSize/1024/1024, groupSize/1024/1024, (_allocatedBufferSize-_currentFileSize)/1024/1024);
return;
}
uint8_t* loc = (uint8_t*)_buffer + _currentFileSize;
memcpy(loc, groupBinary, groupSize);
dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)_buffer + _buffer->header.mappingOffset);
_buffer->header.dylibsImageGroupAddr = mappings[2].address + (_currentFileSize - mappings[2].fileOffset);
_buffer->header.dylibsImageGroupSize = (uint32_t)groupSize;
_currentFileSize += groupSize;
free((void*)groupBinary);
}
void CacheBuilder::addCachedOtherDylibsImageGroup(dyld3::ImageProxyGroup* otherGroup)
{
const dyld3::launch_cache::binary_format::ImageGroup* groupBinary = otherGroup->makeImageGroupBinary(_diagnostics);
if (!groupBinary)
return;
dyld3::launch_cache::ImageGroup group(groupBinary);
size_t groupSize = group.size();
if ( _currentFileSize+groupSize > _allocatedBufferSize ) {
_diagnostics.error("cache buffer too small to hold group[1] info (buffer size=%lldMB, group size=%ldMB, free space=%lldMB)",
_allocatedBufferSize/1024/1024, groupSize/1024/1024, (_allocatedBufferSize-_currentFileSize)/1024/1024);
return;
}
uint8_t* loc = (uint8_t*)_buffer + _currentFileSize;
memcpy(loc, groupBinary, groupSize);
dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)_buffer + _buffer->header.mappingOffset);
_buffer->header.otherImageGroupAddr = mappings[2].address + (_currentFileSize - mappings[2].fileOffset);
_buffer->header.otherImageGroupSize = (uint32_t)groupSize;
_currentFileSize += groupSize;
free((void*)groupBinary);
}
void CacheBuilder::addClosures(const std::map<std::string, const dyld3::launch_cache::binary_format::Closure*>& closures)
{
size_t closuresSpace = 0;
for (const auto& entry : closures) {
dyld3::launch_cache::Closure closure(entry.second);
closuresSpace += closure.size();
}
size_t freeSpace = _allocatedBufferSize - _currentFileSize;
if ( closuresSpace > freeSpace ) {
_diagnostics.error("cache buffer too small to hold all closures (buffer size=%lldMB, closures size=%ldMB, free space=%ldMB)",
_allocatedBufferSize/1024/1024, closuresSpace/1024/1024, freeSpace/1024/1024);
return;
}
dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)_buffer + _buffer->header.mappingOffset);
_buffer->header.progClosuresAddr = mappings[2].address + (_currentFileSize - mappings[2].fileOffset);
uint8_t* closuresBase = (uint8_t*)_buffer + _currentFileSize;
std::vector<DylibIndexTrie::Entry> closureEntrys;
uint32_t currentClosureOffset = 0;
for (const auto& entry : closures) {
const dyld3::launch_cache::binary_format::Closure* closBuf = entry.second;
closureEntrys.push_back(DylibIndexTrie::Entry(entry.first, DylibIndex(currentClosureOffset)));
dyld3::launch_cache::Closure closure(closBuf);
size_t size = closure.size();
assert((size % 4) == 0);
memcpy(closuresBase+currentClosureOffset, closBuf, size);
currentClosureOffset += size;
freeSpace -= size;
free((void*)closBuf);
}
_buffer->header.progClosuresSize = currentClosureOffset;
_currentFileSize += currentClosureOffset;
freeSpace = _allocatedBufferSize - _currentFileSize;
DylibIndexTrie closureTrie(closureEntrys);
std::vector<uint8_t> trieBytes;
closureTrie.emit(trieBytes);
while ( (trieBytes.size() % 8) != 0 )
trieBytes.push_back(0);
if ( trieBytes.size() > freeSpace ) {
_diagnostics.error("cache buffer too small to hold all closures trie (buffer size=%lldMB, trie size=%ldMB, free space=%ldMB)",
_allocatedBufferSize/1024/1024, trieBytes.size()/1024/1024, freeSpace/1024/1024);
return;
}
memcpy((uint8_t*)_buffer + _currentFileSize, &trieBytes[0], trieBytes.size());
_buffer->header.progClosuresTrieAddr = mappings[2].address + (_currentFileSize - mappings[2].fileOffset);
_buffer->header.progClosuresTrieSize = trieBytes.size();
_currentFileSize += trieBytes.size();
}