3 #include "GateKeeper.h"
4 #include "pEpCOMServerAdapter.h"
5 #include "utf8_helper.h"
9 // from https://msdn.microsoft.com/en-us/library/windows/desktop/dd388945(v=vs.85).aspx
11 struct PUBLIC_KEY_VALUES {
12 BLOBHEADER blobheader;
17 static void ReverseMemCopy(
19 _In_ BYTE const *pbSource,
23 for (DWORD i = 0; i < cb; i++) {
24 pbDest[cb - 1 - i] = pbSource[i];
28 static NTSTATUS ImportRsaPublicKey(
29 _In_ BCRYPT_ALG_HANDLE hAlg, // CNG provider
30 _In_ PUBLIC_KEY_VALUES *pKey, // Pointer to the RSAPUBKEY blob.
31 _In_ BCRYPT_KEY_HANDLE *phKey // Receives a handle the imported public key.
36 BYTE *pbPublicKey = NULL;
39 // Layout of the RSA public key blob:
41 // +----------------------------------------------------------------+
42 // | BCRYPT_RSAKEY_BLOB | BE( dwExp ) | BE( Modulus ) |
43 // +----------------------------------------------------------------+
45 // sizeof(BCRYPT_RSAKEY_BLOB) cbExp cbModulus
46 // <--------------------------><------------><---------------------->
48 // BE = Big Endian Format
50 DWORD cbModulus = (pKey->rsapubkey.bitlen + 7) / 8;
51 DWORD dwExp = pKey->rsapubkey.pubexp;
52 DWORD cbExp = (dwExp & 0xFF000000) ? 4 :
53 (dwExp & 0x00FF0000) ? 3 :
54 (dwExp & 0x0000FF00) ? 2 : 1;
56 BCRYPT_RSAKEY_BLOB *pRsaBlob;
59 if (!SUCCEEDED(hr = DWordAdd(cbModulus, sizeof(BCRYPT_RSAKEY_BLOB), &cbKey))) {
65 pbPublicKey = (PBYTE) CoTaskMemAlloc(cbKey);
66 if (pbPublicKey == NULL) {
71 ZeroMemory(pbPublicKey, cbKey);
72 pRsaBlob = (BCRYPT_RSAKEY_BLOB *) (pbPublicKey);
75 // Make the Public Key Blob Header
78 pRsaBlob->Magic = BCRYPT_RSAPUBLIC_MAGIC;
79 pRsaBlob->BitLength = pKey->rsapubkey.bitlen;
80 pRsaBlob->cbPublicExp = cbExp;
81 pRsaBlob->cbModulus = cbModulus;
82 pRsaBlob->cbPrime1 = 0;
83 pRsaBlob->cbPrime2 = 0;
85 pbCurrent = (PBYTE) (pRsaBlob + 1);
88 // Copy pubExp Big Endian
91 ReverseMemCopy(pbCurrent, (PBYTE) &dwExp, cbExp);
95 // Copy Modulus Big Endian
98 ReverseMemCopy(pbCurrent, pKey->modulus, cbModulus);
101 // Import the public key
104 hr = BCryptImportKeyPair(hAlg, NULL, BCRYPT_RSAPUBLIC_BLOB, phKey, (PUCHAR) pbPublicKey, cbKey, 0);
107 CoTaskMemFree(pbPublicKey);
113 const LPCTSTR GateKeeper::plugin_reg_path = _T("Software\\Microsoft\\Office\\Outlook\\Addins\\pEp");
114 const LPCTSTR GateKeeper::plugin_reg_value_name = _T("LoadBehavior");
115 const LPCTSTR GateKeeper::updater_reg_path = _T("Software\\pEp\\Updater");
117 const time_t GateKeeper::cycle = 7200; // 7200 sec is 2 h
118 const time_t GateKeeper::fraction = 10; // first update is at 10% of cycle
119 const DWORD GateKeeper::waiting = 10000; // 10000 ms is 10 sec
121 GateKeeper::GateKeeper(CpEpCOMServerAdapterModule * self)
122 : _self(self), now(time(NULL)), next(now + time_diff()), hkUpdater(NULL), hkPluginStart(NULL),
123 internet(NULL), hAES(NULL), hRSA(NULL)
125 DeleteFile(get_lockFile().c_str());
127 LONG lResult = RegOpenCurrentUser(KEY_READ, &cu);
128 assert(lResult == ERROR_SUCCESS);
129 if (lResult == ERROR_SUCCESS)
135 LONG lResult = RegOpenKeyEx(cu, updater_reg_path, 0, KEY_READ, &hkUpdater);
136 assert(lResult == ERROR_SUCCESS);
137 if (lResult != ERROR_SUCCESS)
140 lResult = RegOpenKeyEx(cu, plugin_reg_path, 0, KEY_WRITE, &hkPluginStart);
141 assert(lResult == ERROR_SUCCESS);
142 if (lResult != ERROR_SUCCESS)
144 RegCloseKey(hkPluginStart);
148 GateKeeper::~GateKeeper()
152 RegCloseKey(hkUpdater);
157 time_t GateKeeper::time_diff()
160 static random_device rd;
161 static mt19937 gen(rd());
163 uniform_int_distribution<time_t> dist(0, cycle/fraction);
173 void GateKeeper::keep()
185 next = now + GateKeeper::cycle;
193 void GateKeeper::keep_plugin()
198 LONG lResult = RegOpenKeyEx(cu, plugin_reg_path, 0, KEY_WRITE, &hkPluginStart);
199 assert(lResult == ERROR_SUCCESS);
200 if (lResult != ERROR_SUCCESS)
204 lResult = RegSetValueEx(hkPluginStart, plugin_reg_value_name, 0, REG_DWORD, (const BYTE *) &v, sizeof(DWORD));
205 assert(lResult == ERROR_SUCCESS);
207 RegCloseKey(hkPluginStart);
210 string GateKeeper::update_key()
214 if (key.length() == 0) {
215 HRSRC res = FindResource(_self->hModule(), MAKEINTRESOURCE(IRD_UPDATEKEY), RT_RCDATA);
218 throw runtime_error("FindResource: IRD_UPDATEKEY");
220 HGLOBAL hRes = LoadResource(_self->hModule(), res);
223 throw runtime_error("LoadResource: IRD_UPDATEKEY");
225 key = string((char *)LockResource(hRes), SizeofResource(_self->hModule(), res));
226 UnlockResource(hRes);
232 BCRYPT_KEY_HANDLE GateKeeper::delivery_key()
236 static random_device rd;
237 static mt19937 gen(rd());
239 uniform_int_distribution<int64_t> dist(0, UINT32_MAX);
241 for (int i = 0; i < 8; i++)
242 key.dw_key[i] = (uint32_t) dist(gen);
244 BCRYPT_KEY_HANDLE hKey;
246 NTSTATUS status = BCryptGenerateSymmetricKey(hAES, &hKey, NULL, 0, (PUCHAR) &key, (ULONG) sizeof(aeskey_t), 0);
249 throw runtime_error("BCryptGenerateSymmetricKey");
254 status = BCryptGetProperty(hKey, BCRYPT_KEY_LENGTH, (PUCHAR) &keylength, sizeof(DWORD), &copied, 0);
255 assert(keylength == 256);
261 string GateKeeper::wrapped_delivery_key(BCRYPT_KEY_HANDLE hDeliveryKey)
265 BCRYPT_KEY_HANDLE hUpdateKey;
266 string _update_key = update_key();
268 PCERT_PUBLIC_KEY_INFO uk;
271 BOOL bResult = CryptDecodeObjectEx(X509_ASN_ENCODING, X509_PUBLIC_KEY_INFO,
272 (const BYTE *) _update_key.data(), _update_key.size(), CRYPT_DECODE_ALLOC_FLAG, NULL, &uk, &uk_size);
274 throw runtime_error("CryptDecodeObjectEx: X509_PUBLIC_KEY_INFO");
276 PUBLIC_KEY_VALUES *_uk;
279 bResult = CryptDecodeObjectEx(X509_ASN_ENCODING, RSA_CSP_PUBLICKEYBLOB,
280 uk->PublicKey.pbData, uk->PublicKey.cbData, CRYPT_DECODE_ALLOC_FLAG, NULL, &_uk, &_uk_size);
283 throw runtime_error("CryptDecodeObjectEx: X509_PUBLIC_KEY_INFO");
285 HRESULT hResult = ImportRsaPublicKey(hRSA, _uk, &hUpdateKey);
288 throw runtime_error("ImportRsaPublicKey");
291 NTSTATUS status = BCryptGetProperty(hUpdateKey, BCRYPT_ALGORITHM_NAME, NULL, 0, &psize, 0);
292 char *prop = new char[psize];
293 TCHAR *_prop = (TCHAR *) prop;
294 BCryptGetProperty(hUpdateKey, BCRYPT_ALGORITHM_NAME, (PUCHAR) prop, psize, &psize, 0);
297 status = BCryptExportKey(hDeliveryKey, NULL, BCRYPT_KEY_DATA_BLOB, NULL, NULL,
300 throw runtime_error("BCryptExportKey: measuring export size");
302 PUCHAR _delivery_key = new UCHAR[export_size];
304 status = BCryptExportKey(hDeliveryKey, NULL, BCRYPT_KEY_DATA_BLOB, _delivery_key, export_size,
307 delete[] _delivery_key;
308 throw runtime_error("BCryptExportKey: delivery_key");
311 BCRYPT_OAEP_PADDING_INFO pi;
312 memset(&pi, 0, sizeof(BCRYPT_OAEP_PADDING_INFO));
313 pi.pszAlgId = BCRYPT_SHA256_ALGORITHM;
316 PUCHAR _result = NULL;
317 ULONG blob_size = export_size - sizeof(BCRYPT_KEY_DATA_BLOB_HEADER);
318 PUCHAR blob = _delivery_key + sizeof(BCRYPT_KEY_DATA_BLOB_HEADER);
319 status = BCryptEncrypt(hUpdateKey, blob, blob_size, &pi, NULL, 0, NULL, 0, &result_size, BCRYPT_PAD_OAEP);
321 delete[] _delivery_key;
322 BCryptDestroyKey(hUpdateKey);
323 throw runtime_error("BCryptEncrypt: calculating result size");
326 _result = new UCHAR[result_size];
327 status = BCryptEncrypt(hUpdateKey, blob, blob_size, &pi, NULL, 0, _result, result_size, &copied, BCRYPT_PAD_OAEP);
328 delete[] _delivery_key;
330 BCryptDestroyKey(hUpdateKey);
332 throw runtime_error("BCryptEncrypt: encrypting using update_key");
335 BCryptDestroyKey(hUpdateKey);
338 for (ULONG i = 0; i < copied; i++) {
339 s << hex << setw(2) << setfill('0');
340 s << (int) _result[i];
348 GateKeeper::product_list GateKeeper::registered_products()
350 product_list products;
352 // https://msdn.microsoft.com/en-us/library/windows/desktop/ms724872(v=vs.85).aspx
353 TCHAR value_name[16384];
354 DWORD value_name_size;
355 TCHAR value[L_MAX_URL_LENGTH + 1];
358 LONG lResult = ERROR_SUCCESS;
359 for (DWORD i = 0; lResult == ERROR_SUCCESS; i++) {
360 value_name_size = 16383;
361 value_size = L_MAX_URL_LENGTH + 1;
362 lResult = RegEnumValue(hkUpdater, i, value_name, &value_name_size, NULL, NULL, (LPBYTE) value, &value_size);
363 if (lResult == ERROR_SUCCESS) {
364 products.push_back({ value_name, value });
371 void GateKeeper::install_msi(tstring filename)
373 HANDLE hMutex = CreateMutex(NULL, TRUE, _T("PEPINSTALLERMUTEX"));
376 ShellExecute(NULL, _T("open"), filename.c_str(), NULL, NULL, SW_SHOW);
380 tstring GateKeeper::get_lockFile()
382 static const tstring _fileName = _T("\\pEpSetup.lck");
383 static tstring fileName;
385 if (fileName.length() == 0) {
386 unique_ptr < TCHAR[] > _pathName(new TCHAR[MAX_PATH + 1]);
387 DWORD size = GetTempPath(MAX_PATH, _pathName.get());
388 if (size > MAX_PATH - _fileName.size())
389 throw runtime_error("TEMP path too long");
391 fileName = _pathName.get();
392 fileName += _fileName;
398 void GateKeeper::update_product(product p, DWORD context)
401 HANDLE file = CreateFile(get_lockFile().c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
402 if (file == INVALID_HANDLE_VALUE) {
407 DeleteFile(get_lockFile().c_str());
411 BCRYPT_KEY_HANDLE dk = delivery_key();
413 tstring delivery = utility::utf16_string(wrapped_delivery_key(dk));
415 tstring delivery = wrapped_delivery_key(delivery_key());
417 tstring url = p.second;
418 url += _T("&challenge=");
421 HINTERNET hUrl = InternetOpenUrl(internet, url.c_str(), headers.c_str(), headers.length(),
422 INTERNET_FLAG_EXISTING_CONNECT | INTERNET_FLAG_NO_UI | INTERNET_FLAG_SECURE, context);
429 UCHAR nonce[sizeof(iv)];
433 char *unencrypted_buffer = NULL;
437 InternetReadFile(hUrl, iv, sizeof(iv), &reading);
440 static char buffer[1024*1024];
441 BOOL bResult = InternetReadFile(hUrl, buffer, 1024*1024, &reading);
442 if (!bResult || !reading)
444 crypted += string(buffer, reading);
451 InternetCloseHandle(hUrl);
454 memcpy(nonce, iv, sizeof(iv));
456 BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO authInfo;
457 BCRYPT_INIT_AUTH_MODE_INFO(authInfo);
458 authInfo.pbNonce = nonce;
459 authInfo.cbNonce = sizeof(nonce);
460 authInfo.pbTag = tag;
461 authInfo.cbTag = sizeof(tag);
463 ULONG unencrypted_size;
464 NTSTATUS status = BCryptDecrypt(dk, (PUCHAR) crypted.data(), crypted.size(),
465 &authInfo, iv, sizeof(iv), NULL, 0, &unencrypted_size, 0);
469 unencrypted_buffer = new char[unencrypted_size];
470 PUCHAR crypted_data = (PUCHAR) crypted.data();
471 ULONG crypted_size = (ULONG) crypted.size() - sizeof(tag);
472 memcpy(tag, crypted_data + crypted_size, sizeof(tag));
474 status = BCryptDecrypt(dk, crypted_data, crypted_size,
475 &authInfo, iv, sizeof(iv), (PUCHAR) unencrypted_buffer, unencrypted_size, &unencrypted_size, 0);
479 BCryptDestroyKey(dk);
481 TCHAR temp_path[MAX_PATH + 1];
482 GetTempPath(MAX_PATH, temp_path);
483 filename = temp_path;
484 filename += _T("\\pEp_");
485 filename += delivery.substr(0, 32);
486 filename += _T(".msi");
488 hFile = CreateFile(filename.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
492 WriteFile(hFile, unencrypted_buffer, unencrypted_size, &writing, NULL);
495 install_msi(filename);
500 if (unencrypted_buffer)
501 delete[] unencrypted_buffer;
505 InternetCloseHandle(hUrl);
506 BCryptDestroyKey(dk);
509 void GateKeeper::keep_updated()
511 NTSTATUS status = BCryptOpenAlgorithmProvider(&hAES, BCRYPT_AES_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
515 status = BCryptSetProperty(hAES, BCRYPT_CHAINING_MODE, (PUCHAR) BCRYPT_CHAIN_MODE_GCM, sizeof(BCRYPT_CHAIN_MODE_GCM), 0);
519 status = BCryptOpenAlgorithmProvider(&hRSA, BCRYPT_RSA_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
524 internet = InternetOpen(_T("pEp"), INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
529 product_list products = registered_products();
532 for (auto i = products.begin(); i != products.end(); i++) {
534 update_product(*i, context++);
544 InternetCloseHandle(internet);
546 BCryptCloseAlgorithmProvider(hAES, 0);
548 BCryptCloseAlgorithmProvider(hRSA, 0);