hane 1.0.0

package/vendor/zsign/src/common/sha.cpp

@@ -0,0 +1,133 @@
+#include "sha.h"
+#include "base64.h"
+#include <openssl/sha.h>
+
+bool ZSHA::SHA1(uint8_t* data, size_t size, string& strOutput)
+{
+	strOutput.clear();
+	uint8_t hash[20];
+	memset(hash, 0, 20);
+	::SHA1(data, size, hash);
+	strOutput.append((const char*)hash, 20);
+	return true;
+}
+
+bool ZSHA::SHA256(uint8_t* data, size_t size, string& strOutput)
+{
+	strOutput.clear();
+	uint8_t hash[32];
+	memset(hash, 0, 32);
+	::SHA256(data, size, hash);
+	strOutput.append((const char*)hash, 32);
+	return true;
+}
+
+bool ZSHA::SHA1(const string& strData, string& strOutput)
+{
+	return ZSHA::SHA1((uint8_t*)strData.data(), strData.size(), strOutput);
+}
+
+bool ZSHA::SHA256(const string& strData, string& strOutput)
+{
+	return ZSHA::SHA256((uint8_t*)strData.data(), strData.size(), strOutput);
+}
+
+bool ZSHA::SHA(const string& strData, string& strSHA1, string& strSHA256)
+{
+	ZSHA::SHA1(strData, strSHA1);
+	ZSHA::SHA256(strData, strSHA256);
+	return (!strSHA1.empty() && !strSHA256.empty());
+}
+
+bool ZSHA::SHA1Text(const string& strData, string& strOutput)
+{
+	string strSHASum;
+	ZSHA::SHA1(strData, strSHASum);
+
+	strOutput.clear();
+	char buf[16] = { 0 };
+	for (size_t i = 0; i < strSHASum.size(); i++) {
+		snprintf(buf, sizeof(buf), "%02x", (uint8_t)strSHASum[i]);
+		strOutput += buf;
+	}
+	return (!strOutput.empty());
+}
+
+bool ZSHA::SHAFile(const char* szFile, string& strSHA1, string& strSHA256)
+{
+	strSHA1.clear();
+	strSHA256.clear();
+	size_t sSize = 0;
+	uint8_t* pBase = (uint8_t*)ZFile::MapFile(szFile, 0, 0, &sSize, true);
+	// pBase may be NULL, but it's ok, because the file may be empty
+	ZSHA::SHA1(pBase, sSize, strSHA1);
+	ZSHA::SHA256(pBase, sSize, strSHA256);
+	if (NULL != pBase && sSize > 0) {
+		ZFile::UnmapFile(pBase, sSize);
+	}
+	return (!strSHA1.empty() && !strSHA256.empty());
+}
+
+bool ZSHA::SHABase64(const string& strData, string& strSHA1Base64, string& strSHA256Base64)
+{
+	jbase64 b64;
+	string strSHA1;
+	string strSHA256;
+	SHA(strData, strSHA1, strSHA256);
+	strSHA1Base64 = b64.encode(strSHA1);
+	strSHA256Base64 = b64.encode(strSHA256);
+	return (!strSHA1Base64.empty() && !strSHA256Base64.empty());
+}
+
+bool ZSHA::SHABase64File(const char* szFile, string& strSHA1Base64, string& strSHA256Base64)
+{
+	jbase64 b64;
+	string strSHA1;
+	string strSHA256;
+	SHAFile(szFile, strSHA1, strSHA256);
+	strSHA1Base64 = b64.encode(strSHA1);
+	strSHA256Base64 = b64.encode(strSHA256);
+	return (!strSHA1Base64.empty() && !strSHA256Base64.empty());
+}
+
+void ZSHA::Print(const char* prefix, const uint8_t* hash, uint32_t size, const char* suffix)
+{
+	ZLog::PrintV("%s", prefix);
+	for (uint32_t i = 0; i < size; i++) {
+		ZLog::PrintV("%02x", hash[i]);
+	}
+	ZLog::PrintV("%s", suffix);
+}
+
+void ZSHA::Print(const char* prefix, const string& strSHASum, const char* suffix)
+{
+	Print(prefix, (const uint8_t*)strSHASum.data(), (uint32_t)strSHASum.size(), suffix);
+}
+
+void ZSHA::PrintData1(const char* prefix, const string& strData, const char* suffix)
+{
+	string strSHASum;
+	ZSHA::SHA1(strData, strSHASum);
+	Print(prefix, strSHASum, suffix);
+}
+
+void ZSHA::PrintData1(const char* prefix, uint8_t* data, size_t size, const char* suffix)
+{
+	string strSHASum;
+	ZSHA::SHA1(data, size, strSHASum);
+	Print(prefix, strSHASum, suffix);
+}
+
+void ZSHA::PrintData256(const char* prefix, const string& strData, const char* suffix)
+{
+	string strSHASum;
+	ZSHA::SHA256(strData, strSHASum);
+	Print(prefix, strSHASum, suffix);
+}
+
+void ZSHA::PrintData256(const char* prefix, uint8_t* data, size_t size, const char* suffix)
+{
+	string strSHASum;
+	ZSHA::SHA256(data, size, strSHASum);
+	Print(prefix, strSHASum, suffix);
+}

package/vendor/zsign/src/common/sha.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "common.h"
+
+class ZSHA
+{
+public:
+
+	static bool SHA1(uint8_t* data, size_t size, string& strOutput);
+	static bool SHA1(const string& strData, string& strOutput);
+	static bool SHA256(uint8_t* data, size_t size, string& strOutput);
+	static bool SHA256(const string& strData, string& strOutput);
+	static bool SHA(const string& strData, string& strSHA1, string& strSHA256);
+	static bool SHA1Text(const string& strData, string& strOutput);
+	static bool SHAFile(const char* szFile, string& strSHA1, string& strSHA256);
+	static bool SHABase64(const string& strData, string& strSHA1Base64, string& strSHA256Base64);
+	static bool SHABase64File(const char* szFile, string& strSHA1Base64, string& strSHA256Base64);
+	static void Print(const char* prefix, const uint8_t* hash, uint32_t size, const char* suffix = "\n");
+	static void Print(const char* prefix, const string& strSHASum, const char* suffix = "\n");
+	static void PrintData1(const char* prefix, const string& strData, const char* suffix = "\n");
+	static void PrintData1(const char* prefix, uint8_t* data, size_t size, const char* suffix = "\n");
+	static void PrintData256(const char* prefix, const string& strData, const char* suffix = "\n");
+	static void PrintData256(const char* prefix, uint8_t* data, size_t size, const char* suffix = "\n");
+};

package/vendor/zsign/src/common/timer.cpp

@@ -0,0 +1,28 @@
+#include "timer.h"
+
+ZTimer::ZTimer()
+{
+	Reset();
+}
+
+uint64_t ZTimer::Reset()
+{
+	m_uBeginTime = ZUtil::GetMicroSecond();
+	return m_uBeginTime;
+}
+
+uint64_t ZTimer::Print(const char* szFormatArgs, ...)
+{
+	FORMAT_V(szFormatArgs, szFormat);
+	uint64_t uElapse = ZUtil::GetMicroSecond() - m_uBeginTime;
+	ZLog::PrintV("%s (%.03fs, %lluus)\n", szFormat, uElapse / 1000000.0, uElapse);
+	return Reset();
+}
+
+uint64_t ZTimer::PrintResult(bool bSuccess, const char* szFormatArgs, ...)
+{
+	FORMAT_V(szFormatArgs, szFormat);
+	uint64_t uElapse = ZUtil::GetMicroSecond() - m_uBeginTime;
+	ZLog::PrintResultV(bSuccess, "%s (%.03fs, %lluus)\n", szFormat, uElapse / 1000000.0, uElapse);
+	return Reset();
+}

package/vendor/zsign/src/common/timer.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "common.h"
+
+class ZTimer
+{
+public:
+	ZTimer();
+
+public:
+	uint64_t Reset();
+	uint64_t Print(const char* szFormatArgs, ...);
+	uint64_t PrintResult(bool bSuccess, const char* szFormatArgs, ...);
+
+private:
+	uint64_t m_uBeginTime;
+};

package/vendor/zsign/src/common/util.cpp

@@ -0,0 +1,185 @@
+#include "util.h"
+
+#ifdef _WIN32
+#define PRId64						"lld"
+#elif __APPLE__
+#define PRId64						"lld"
+#else
+#define PRId64						"ld"
+#endif
+
+string ZUtil::FormatSize(int64_t size, int64_t base)
+{
+	double fsize = 0;
+	char ret[64] = { 0 };
+	if (size > base * base * base * base) {
+		fsize = (size * 1.0) / (base * base * base * base);
+		snprintf(ret, sizeof(ret), "%.2f TB", fsize);
+	} else if (size > base * base * base) {
+		fsize = (size * 1.0) / (base * base * base);
+		snprintf(ret, sizeof(ret), "%.2f GB", fsize);
+	} else if (size > base * base) {
+		fsize = (size * 1.0) / (base * base);
+		snprintf(ret, sizeof(ret), "%.2f MB", fsize);
+	} else if (size > base) {
+		fsize = (size * 1.0) / (base);
+		snprintf(ret, sizeof(ret), "%.2f KB", fsize);
+	} else {
+		snprintf(ret, sizeof(ret), "%" PRId64 " B", size);
+	}
+	return ret;
+}
+
+time_t ZUtil::GetUnixStamp()
+{
+	time_t ustime = 0;
+	time(&ustime);
+	return ustime;
+}
+
+uint64_t ZUtil::GetMicroSecond()
+{
+#ifdef _WIN32
+	LARGE_INTEGER frequency, counter;
+	QueryPerformanceFrequency(&frequency);
+	QueryPerformanceCounter(&counter);
+	return (counter.QuadPart * 1000000) / frequency.QuadPart;
+#else
+	struct timeval tv = { 0 };
+	gettimeofday(&tv, NULL);
+	return tv.tv_sec * 1000000 + tv.tv_usec;
+#endif
+}
+
+bool  ZUtil::SystemExecV(const char* szCmd, ...)
+{
+	FORMAT_V(szCmd, szRealCmd);
+
+	if (strlen(szRealCmd) <= 0) {
+		return false;
+	}
+
+	int status = system(szRealCmd);
+	if (0 != status) {
+		ZLog::ErrorV("SystemExec: \"%s\", error!\n", szRealCmd);
+		return false;
+	}
+	return true;
+}
+
+uint16_t ZUtil::Swap(uint16_t value)
+{
+	return ((value >> 8) & 0x00ff) | ((value << 8) & 0xff00);
+}
+
+uint32_t ZUtil::Swap(uint32_t value)
+{
+	value = ((value >> 8) & 0x00ff00ff) | ((value << 8) & 0xff00ff00);
+	value = ((value >> 16) & 0x0000ffff) | ((value << 16) & 0xffff0000);
+	return value;
+}
+
+uint64_t ZUtil::Swap(uint64_t value)
+{
+	value = (value & 0x00000000ffffffffULL) << 32 | (value & 0xffffffff00000000ULL) >> 32;
+	value = (value & 0x0000ffff0000ffffULL) << 16 | (value & 0xffff0000ffff0000ULL) >> 16;
+	value = (value & 0x00ff00ff00ff00ffULL) << 8 | (value & 0xff00ff00ff00ff00ULL) >> 8;
+	return value;
+}
+
+uint32_t ZUtil::ByteAlign(uint32_t uValue, uint32_t uAlign)
+{
+	return (uValue + (uAlign - uValue % uAlign));
+}
+
+const char* ZUtil::StringFormatV(string& strFormat, const char* szFormatArgs, ...)
+{
+	FORMAT_V(szFormatArgs, szFormat);
+	strFormat = szFormat;
+	return strFormat.c_str();
+}
+
+string& ZUtil::StringReplace(string& context, const string& from, const string& to)
+{
+	size_t lookHere = 0;
+	size_t foundHere;
+	while ((foundHere = context.find(from, lookHere)) != string::npos) {
+		context.replace(foundHere, from.size(), to);
+		lookHere = foundHere + to.size();
+	}
+	return context;
+}
+
+void ZUtil::StringSplit(const string& src, const string& split, vector<string>& dest)
+{
+	size_t oldPos = 0;
+	size_t newPos = src.find(split, oldPos);
+	while (newPos != string::npos) {
+		dest.push_back(src.substr(oldPos, newPos - oldPos));
+		oldPos = newPos + split.size();
+		newPos = src.find(split, oldPos);
+	}
+	if (oldPos < src.size()) {
+		dest.push_back(src.substr(oldPos));
+	}
+}
+
+string& ZUtil::StringTrim(string& str)
+{
+	if (!str.empty()) {
+		str.erase(0, str.find_first_not_of(' '));
+		str.erase(str.find_last_not_of(' ') + 1);
+		str.erase(0, str.find_first_not_of('\t'));
+		str.erase(str.find_last_not_of('\t') + 1);
+		str.erase(0, str.find_first_not_of('\r'));
+		str.erase(str.find_last_not_of('\r') + 1);
+		str.erase(0, str.find_first_not_of('\n'));
+		str.erase(str.find_last_not_of('\n') + 1);
+	}
+	return str;
+}
+
+const char* ZUtil::GetBaseName(const char* path)
+{
+#ifdef _WIN32
+	return ::PathFindFileNameA(path);
+#else
+	return ::basename((char*)path);
+#endif
+}
+
+int ZUtil::builtin_clzll(uint64_t x)
+{
+	//__builtin_clzll(x);
+
+	if (x == 0) {
+		return 64;
+	}
+
+	int count = 0;
+	if (x <= 0x00000000FFFFFFFF) { 
+		count += 32; 
+		x <<= 32;
+	}
+	if (x <= 0x0000FFFFFFFFFFFF) { 
+		count += 16; 
+		x <<= 16;
+	}
+	if (x <= 0x00FFFFFFFFFFFFFF) { 
+		count += 8;  
+		x <<= 8;
+	}
+	if (x <= 0x0FFFFFFFFFFFFFFF) { 
+		count += 4;  
+		x <<= 4;
+	}
+	if (x <= 0x3FFFFFFFFFFFFFFF) { 
+		count += 2;  
+		x <<= 2;
+	}
+	if (x <= 0x7FFFFFFFFFFFFFFF) { 
+		count += 1;
+	}
+
+	return count;
+}

package/vendor/zsign/src/common/util.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "common.h"
+
+class ZUtil
+{
+public:
+	static const char* 	StringFormatV(string& strFormat, const char* szFormatArgs, ...);
+	static string& 		StringReplace(string& context, const string& from, const string& to);
+	static void 		StringSplit(const string& src, const string& split, vector<string>& dest);
+	static string&		StringTrim(string& str);
+	static string 		FormatSize(int64_t size, int64_t base = 1024);
+	static time_t		GetUnixStamp();
+	static uint64_t 	GetMicroSecond();
+	static bool			SystemExecV(const char* szCmd, ...);
+	static uint32_t		ByteAlign(uint32_t uValue, uint32_t uAlign);
+	static const char*	GetBaseName(const char* path);
+	static int			builtin_clzll(uint64_t x);
+	static uint16_t		Swap(uint16_t value);
+	static uint32_t		Swap(uint32_t value);
+	static uint64_t		Swap(uint64_t value);
+};
+
+#define LE(x) ZUtil::Swap(x)
+#define BE(x) ZUtil::Swap(x)

package/vendor/zsign/src/macho.cpp

@@ -0,0 +1,273 @@
+#include "common.h"
+#include "json.h"
+#include "mach-o.h"
+#include "openssl.h"
+#include "signing.h"
+#include "macho.h"
+
+ZMachO::ZMachO()
+{
+	m_pBase = NULL;
+	m_sSize = 0;
+	m_bCSRealloced = false;
+}
+
+ZMachO::~ZMachO()
+{
+	FreeArchOes();
+}
+
+bool ZMachO::Init(const char* szFile)
+{
+	m_strFile = szFile;
+	return OpenFile(szFile);
+}
+
+bool ZMachO::InitV(const char* szPath, ...)
+{
+	FORMAT_V(szPath, szFile);
+	return Init(szFile);
+}
+
+bool ZMachO::Free()
+{
+	FreeArchOes();
+	return CloseFile();
+}
+
+bool ZMachO::NewArchO(uint8_t* pBase, uint32_t uLength)
+{
+	ZArchO* archo = new ZArchO();
+	if (archo->Init(pBase, uLength)) {
+		m_arrArchOes.push_back(archo);
+		return true;
+	}
+	delete archo;
+	return false;
+}
+
+void ZMachO::FreeArchOes()
+{
+	for (size_t i = 0; i < m_arrArchOes.size(); i++) {
+		ZArchO* archo = m_arrArchOes[i];
+		delete archo;
+	}
+	m_pBase = NULL;
+	m_sSize = 0;
+	m_arrArchOes.clear();
+}
+
+bool ZMachO::OpenFile(const char* szPath)
+{
+	FreeArchOes();
+
+	m_sSize = 0;
+	m_pBase = (uint8_t*)ZFile::MapFile(szPath, 0, 0, &m_sSize, false);
+	if (NULL != m_pBase) {
+		uint32_t magic = *((uint32_t*)m_pBase);
+		if (FAT_CIGAM == magic || FAT_MAGIC == magic) {
+			fat_header* pFatHeader = (fat_header*)m_pBase;
+			int nFatArch = (FAT_MAGIC == magic) ? pFatHeader->nfat_arch : LE(pFatHeader->nfat_arch);
+			for (int i = 0; i < nFatArch; i++) {
+				fat_arch* pFatArch = (fat_arch*)(m_pBase + sizeof(fat_header) + sizeof(fat_arch) * i);
+				uint8_t* pArchBase = m_pBase + ((FAT_MAGIC == magic) ? pFatArch->offset : LE(pFatArch->offset));
+				uint32_t uArchLength = (FAT_MAGIC == magic) ? pFatArch->size : LE(pFatArch->size);
+				if (!NewArchO(pArchBase, uArchLength)) {
+					ZLog::ErrorV(">>> Invalid arch file in fat mach-o file!\n");
+					return false;
+				}
+			}
+		} else if (MH_MAGIC == magic || MH_CIGAM == magic || MH_MAGIC_64 == magic || MH_CIGAM_64 == magic) {
+			if (!NewArchO(m_pBase, (uint32_t)m_sSize)) {
+				ZLog::ErrorV(">>> Invalid mach-o file!\n");
+				return false;
+			}
+		} else {
+			ZLog::ErrorV(">>> Invalid mach-o file (2)!\n");
+			return false;
+		}
+	}
+
+	return (!m_arrArchOes.empty());
+}
+
+bool ZMachO::CloseFile()
+{
+	if (NULL == m_pBase || m_sSize <= 0) {
+		return false;
+	}
+
+	if (!ZFile::UnmapFile((void*)m_pBase, m_sSize)) {
+		ZLog::ErrorV(">>> CodeSign write(munmap) failed! Error: %p, %lu, %s\n", m_pBase, m_sSize, strerror(errno));
+		return false;
+	}
+	return true;
+}
+
+void ZMachO::PrintInfo()
+{
+	for (size_t i = 0; i < m_arrArchOes.size(); i++) {
+		ZArchO* archo = m_arrArchOes[i];
+		archo->PrintInfo();
+	}
+}
+
+bool ZMachO::CheckSignature() const
+{
+	return std::all_of(m_arrArchOes.cbegin(), m_arrArchOes.cend(), 
+		[](ZArchO const * archo) {
+			return archo->IsSigned();
+		}
+	);
+}
+
+bool ZMachO::Sign(ZSignAsset* pSignAsset, bool bForce, string strBundleId, string strInfoSHA1, string strInfoSHA256, const string& strCodeResourcesData)
+{
+	if (NULL == m_pBase || m_arrArchOes.empty()) {
+		return false;
+	}
+
+	for (size_t i = 0; i < m_arrArchOes.size(); i++) {
+		ZArchO* archo = m_arrArchOes[i];
+		if (strBundleId.empty()) {
+			jvalue jvInfo;
+			jvInfo.read_plist(archo->m_strInfoPlist);
+			strBundleId = jvInfo["CFBundleIdentifier"].as_cstr();
+			if (strBundleId.empty()) {
+				strBundleId = ZUtil::GetBaseName(m_strFile.c_str());
+			}
+		}
+
+		if (strInfoSHA1.empty() || strInfoSHA256.empty()) {
+			if (archo->m_strInfoPlist.empty()) {
+				strInfoSHA1.append(20, 0);
+				strInfoSHA256.append(32, 0);
+			} else {
+				ZSHA::SHA(archo->m_strInfoPlist, strInfoSHA1, strInfoSHA256);
+			}
+		}
+
+		if (!archo->Sign(pSignAsset, bForce, strBundleId, strInfoSHA1, strInfoSHA256, strCodeResourcesData)) {
+			if (!archo->m_bEnoughSpace && !m_bCSRealloced) {
+				m_bCSRealloced = true;
+				if (ReallocCodeSignSpace()) {
+					return Sign(pSignAsset, bForce, strBundleId, strInfoSHA1, strInfoSHA256, strCodeResourcesData);
+				}
+			}
+			return false;
+		}
+	}
+
+	return CloseFile();
+}
+
+bool ZMachO::ReallocCodeSignSpace()
+{
+	ZLog::Warn(">>> Realloc CodeSignature space... \n");
+
+	vector<uint32_t> arrMachOesSizes;
+	for (size_t i = 0; i < m_arrArchOes.size(); i++) {
+		string strNewArchOFile;
+		ZUtil::StringFormatV(strNewArchOFile, "%s.archo.%d", m_strFile.c_str(), i);
+		uint32_t uNewLength = m_arrArchOes[i]->ReallocCodeSignSpace(strNewArchOFile);
+		if (uNewLength <= 0) {
+			ZLog::Error(">>> Failed!\n");
+			return false;
+		}
+		arrMachOesSizes.push_back(uNewLength);
+	}
+	ZLog::Warn(">>> Success!\n");
+
+	if (1 == m_arrArchOes.size()) {
+		CloseFile();
+		ZFile::RemoveFile(m_strFile.c_str());
+		string strNewArchOFile = m_strFile + ".archo.0";
+		if (0 == rename(strNewArchOFile.c_str(), m_strFile.c_str())) {
+			return OpenFile(m_strFile.c_str());
+		}
+	} else { //fat
+		uint32_t uAlign = 16384;
+		vector<fat_arch> arrArches;
+		fat_header fath = *((fat_header*)m_pBase);
+		int nFatArch = (FAT_MAGIC == fath.magic) ? fath.nfat_arch : LE(fath.nfat_arch);
+		for (int i = 0; i < nFatArch; i++) {
+			fat_arch arch = *((fat_arch*)(m_pBase + sizeof(fat_header) + sizeof(fat_arch) * i));
+			arrArches.push_back(arch);
+		}
+		CloseFile();
+
+		if (arrArches.size() != m_arrArchOes.size()) {
+			return false;
+		}
+
+		uint32_t uFatHeaderSize = sizeof(fat_header) + (uint32_t)arrArches.size() * sizeof(fat_arch);
+		uint32_t uPadding1 = (uAlign - uFatHeaderSize % uAlign);
+		uint32_t uOffset = uFatHeaderSize + uPadding1;
+		for (size_t i = 0; i < arrArches.size(); i++) {
+			fat_arch& arch = arrArches[i];
+			uint32_t& uMachOSize = arrMachOesSizes[i];
+
+			arch.align = (FAT_MAGIC == fath.magic) ? 14 : BE((uint32_t)14);
+			arch.offset = (FAT_MAGIC == fath.magic) ? uOffset : BE(uOffset);
+			arch.size = (FAT_MAGIC == fath.magic) ? uMachOSize : BE(uMachOSize);
+
+			uOffset += uMachOSize;
+			uOffset = uOffset + (uAlign - uOffset % uAlign);
+		}
+
+		string strNewFatMachOFile = m_strFile + ".fato";
+
+		string strFatHeader;
+		strFatHeader.append((const char*)&fath, sizeof(fat_header));
+		for (size_t i = 0; i < arrArches.size(); i++) {
+			fat_arch& arch = arrArches[i];
+			strFatHeader.append((const char*)&arch, sizeof(fat_arch));
+		}
+
+		string strPadding1;
+		strPadding1.append(uPadding1, 0);
+
+		ZFile::AppendFile(strNewFatMachOFile.c_str(), strFatHeader);
+		ZFile::AppendFile(strNewFatMachOFile.c_str(), strPadding1);
+
+		for (size_t i = 0; i < arrArches.size(); i++) {
+			size_t sSize = 0;
+			string strNewArchOFile = m_strFile + ".archo." + jvalue((int)i).as_string();
+			uint8_t* pData = (uint8_t*)ZFile::MapFile(strNewArchOFile.c_str(), 0, 0, &sSize, true);
+			if (NULL == pData) {
+				ZFile::RemoveFile(strNewFatMachOFile.c_str());
+				return false;
+			}
+			string strPadding;
+			strPadding.append((uAlign - sSize % uAlign), 0);
+
+			ZFile::AppendFile(strNewFatMachOFile.c_str(), (const char*)pData, sSize);
+			ZFile::AppendFile(strNewFatMachOFile.c_str(), strPadding);
+
+			ZFile::UnmapFile((void*)pData, sSize);
+			ZFile::RemoveFile(strNewArchOFile.c_str());
+		}
+
+		ZFile::RemoveFile(m_strFile.c_str());
+		if (0 == rename(strNewFatMachOFile.c_str(), m_strFile.c_str())) {
+			return OpenFile(m_strFile.c_str());
+		}
+	}
+
+	return false;
+}
+
+bool ZMachO::InjectDylib(bool bWeakInject, const char* szDylibFile)
+{
+	ZLog::WarnV(">>> InjectDylib: %s %s... \n", szDylibFile, bWeakInject ? "(weak)" : "");
+
+	vector<uint32_t> arrMachOesSizes;
+	for (size_t i = 0; i < m_arrArchOes.size(); i++) {
+		if (!m_arrArchOes[i]->InjectDylib(bWeakInject, szDylibFile)) {
+			ZLog::Error(">>> Failed!\n");
+			return false;
+		}
+	}
+	ZLog::Warn(">>> Success!\n");
+	return true;
+}