1 files changed, 12 insertions, 17 deletions
diff --git a/src/Common/Dlgcode.c b/src/Common/Dlgcode.c
index b91167d4..ba0173ac 100644
--- a/src/Common/Dlgcode.c
+++ b/src/Common/Dlgcode.c
@@ -832,65 +832,60 @@ BOOL TCCopyFile (wchar_t *sourceFileName, wchar_t *destinationFile)
 		GENERIC_READ,
 		FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
 
 	if (src == INVALID_HANDLE_VALUE)
 		return FALSE;
 
 	dst = CreateFileW (destinationFile,
 		GENERIC_WRITE,
 		0, NULL, CREATE_ALWAYS, 0, NULL);
 
 	if (dst == INVALID_HANDLE_VALUE)
 	{
 		CloseHandle (src);
 		return FALSE;
 	}
 
 	return TCCopyFileBase (src, dst);
 }
 
 
 BOOL VerifyModuleSignature (const wchar_t* path)
 {
 #if defined(NDEBUG) && !defined (VC_SKIP_OS_DRIVER_REQ_CHECK)
 	BOOL bResult = FALSE;
 	HRESULT hResult;
 	GUID gActionID = WINTRUST_ACTION_GENERIC_VERIFY_V2;
 	WINTRUST_FILE_INFO  fileInfo = {0};
 	WINTRUST_DATA      WVTData = {0};
 	wchar_t filePath [TC_MAX_PATH + 1024];
 
-    // we check our own authenticode signature only starting from Windows 10 since this is
-	// the minimal supported OS apart from XP where we can't verify SHA256 signatures
-	if (!IsOSAtLeast (WIN_10))
-		return TRUE;
-
 	// Strip quotation marks (if any)
 	if (path [0] == L'"')
 	{
 		StringCbCopyW (filePath, sizeof(filePath), path + 1);
 	}
 	else
 	{
 		StringCbCopyW (filePath, sizeof(filePath), path);
 	}
 
 	// Strip quotation marks (if any)
 	if (filePath [wcslen (filePath) - 1] == L'"')
 		filePath [wcslen (filePath) - 1] = 0;
 
 	fileInfo.cbStruct = sizeof(WINTRUST_FILE_INFO);
 	fileInfo.pcwszFilePath = filePath;
 	fileInfo.hFile = NULL;
 
 	WVTData.cbStruct            = sizeof(WINTRUST_DATA);
 	WVTData.dwUIChoice          = WTD_UI_NONE;
 	WVTData.fdwRevocationChecks = WTD_REVOKE_NONE;
 	WVTData.dwUnionChoice       = WTD_CHOICE_FILE;
 	WVTData.pFile               = &fileInfo;
 	WVTData.dwStateAction       = WTD_STATEACTION_VERIFY;
 	WVTData.dwProvFlags         = WTD_REVOCATION_CHECK_NONE | WTD_CACHE_ONLY_URL_RETRIEVAL;
 
 	hResult = WinVerifyTrust(0, &gActionID, &WVTData);
 	if (0 == hResult)
 	{
 		PCRYPT_PROVIDER_DATA pProviderData = WTHelperProvDataFromStateData (WVTData.hWVTStateData);
@@ -3576,64 +3571,64 @@ extern "C" {
 
 		// activate process mitigations (currently only ASLR, dynamic code and extensions points)
 		ActivateProcessMitigations();
 
 #ifndef SETUP
 		// call ActivateMemoryProtection if corresponding setting has been enabled (default is enabled)
 		if (ReadMemoryProtectionConfig())
 		{
 			ActivateMemoryProtection();
 		}
 #endif
 		return wWinMainCRTStartup();
 	}
 }
 #endif
 
 /* InitApp - initialize the application, this function is called once in the
    applications WinMain function, but before the main dialog has been created */
 void InitApp (HINSTANCE hInstance, wchar_t *lpszCommandLine)
 {
 	WNDCLASSW wc;
 	char langId[6];	
 	SetDefaultDllDirectoriesPtr SetDefaultDllDirectoriesFn = NULL;
 #if !defined(SETUP)
 	wchar_t modPath[MAX_PATH];
 #endif
 	INITCOMMONCONTROLSEX InitCtrls;
 
 	InitOSVersionInfo();
 
-	if (!IsOSAtLeast (WIN_7))
+	if (!IsOSAtLeast (WIN_10))
 	{
-		// abort using a message that says that VeraCrypt can run only on Windows 7 and later and that it is officially supported only on Windows 10 and later
-		AbortProcessDirect(L"VeraCrypt requires at least Windows 7 to run.");
+		// abort using a message that says that VeraCrypt can run only on Windows 10 and later
+		AbortProcessDirect(L"VeraCrypt requires at least Windows 10 to run.");
 	}
 
 	SetDefaultDllDirectoriesFn = (SetDefaultDllDirectoriesPtr) GetProcAddress (GetModuleHandle(L"kernel32.dll"), "SetDefaultDllDirectories");
 	if (!SetDefaultDllDirectoriesFn)
 	{
 		// This can happen only if KB2533623 is missing from Windows 7
 		AbortProcessDirect(L"VeraCrypt requires KB2533623 to be installed on Windows 7 and Windows Server 2008 R2 in order to run.");
 	}
 
 	VirtualLock (&CmdTokenPin, sizeof (CmdTokenPin));
 
 	InitGlobalLocks ();
 	
 	// call InitCommonControlsEx function to initialize the common controls
 	InitCtrls.dwSize = sizeof (InitCtrls);
 	InitCtrls.dwICC = ICC_WIN95_CLASSES | ICC_PAGESCROLLER_CLASS | ICC_NATIVEFNTCTL_CLASS | ICC_STANDARD_CLASSES | ICC_LINK_CLASS;
 	InitCommonControlsEx (&InitCtrls);
 
 	// Load RichEdit library in order to be able to use RichEdit20W class
 	LoadLibraryEx (L"Riched20.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
 
 #if !defined(SETUP)
 	GetModuleFileNameW (NULL, modPath, ARRAYSIZE (modPath));
 	if (!VerifyModuleSignature (modPath))
 		AbortProcessDirect (L"This distribution package is damaged. Please try downloading it again (preferably from the official VeraCrypt website at https://www.veracrypt.fr).");
 #endif
 
 #ifndef SETUP
 	/* enable drag-n-drop when we are running elevated */
 	AllowMessageInUIPI (WM_DROPFILES);
@@ -6239,99 +6234,99 @@ static BOOL PerformBenchmark(HWND hBenchDlg, HWND hwndDlg)
 						STREEBOG_init(&stctx);
 						STREEBOG_add(&stctx, lpTestBuffer, benchmarkBufferSize);
 						STREEBOG_finalize(&stctx, (unsigned char *)digest);
 						break;
 
 					}
 			        #endif	
                                 }
 
 				if (QueryPerformanceCounter (&performanceCountEnd) == 0)
 					goto counter_error;
 
 				benchmarkTable[benchmarkTotalItems].encSpeed = performanceCountEnd.QuadPart - performanceCountStart.QuadPart;
 
 				benchmarkTable[benchmarkTotalItems].decSpeed = benchmarkTable[benchmarkTotalItems].encSpeed;
 				benchmarkTable[benchmarkTotalItems].id = hid;
 				benchmarkTable[benchmarkTotalItems].meanBytesPerSec = (unsigned __int64) (benchmarkBufferSize / ((float) benchmarkTable[benchmarkTotalItems].encSpeed / benchmarkPerformanceFrequency.QuadPart / 2));
 				StringCbPrintfW (benchmarkTable[benchmarkTotalItems].name, sizeof(benchmarkTable[benchmarkTotalItems].name),L"%s", HashGetName(hid));
 
 				benchmarkTotalItems++;
 			}
 		}
 	break;
 
 	case BENCHMARK_TYPE_PRF:
 	/* Measures the time that it takes for the PKCS-5 routine to derive a header key using
 	   each of the implemented PRF algorithms. 
 	*/
 	{
 		int thid, i;
-		char dk[MASTER_KEYDATA_SIZE];
+		unsigned char dk[MASTER_KEYDATA_SIZE];
 		char *tmp_salt = {"\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x01\x23\x45\x67\x89\xAB\xCD\xEF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x01\x23\x45\x67\x89\xAB\xCD\xEF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF"};
 
 		for (thid = FIRST_PRF_ID; thid <= LAST_PRF_ID; thid++) 
 		{
 			if (benchmarkPreBoot && !benchmarkGPT && !HashForSystemEncryption (thid))
 				continue;
 
 			if (QueryPerformanceCounter (&performanceCountStart) == 0)
 				goto counter_error;
 
 			for (i = 1; i <= 2; i++) 
 			{
 				switch (thid)
 				{
 
 				case SHA512:
 					/* PKCS-5 test with HMAC-SHA-512 used as the PRF */
-					derive_key_sha512 ("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);
+					derive_key_sha512 ((unsigned char*) "passphrase-1234567890", 21, (unsigned char*) tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);
 					break;
 
 				case SHA256:
 					/* PKCS-5 test with HMAC-SHA-256 used as the PRF */
-					derive_key_sha256 ("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);
+					derive_key_sha256 ((unsigned char*)"passphrase-1234567890", 21, (unsigned char*) tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);
 					break;
                           #ifndef WOLFCRYPT_BACKEND
 				case BLAKE2S:
 					/* PKCS-5 test with HMAC-BLAKE2s used as the PRF */
-					derive_key_blake2s ("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);
+					derive_key_blake2s ((unsigned char*)"passphrase-1234567890", 21, (unsigned char*) tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);
 					break;
 
 				case WHIRLPOOL:
 					/* PKCS-5 test with HMAC-Whirlpool used as the PRF */
-					derive_key_whirlpool ("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);
+					derive_key_whirlpool ((unsigned char*)"passphrase-1234567890", 21, (unsigned char*) tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);
 					break;
 
 				case STREEBOG:
 					/* PKCS-5 test with HMAC-STREEBOG used as the PRF */
-					derive_key_streebog("passphrase-1234567890", 21, tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);
+					derive_key_streebog((unsigned char*)"passphrase-1234567890", 21, (unsigned char*) tmp_salt, 64, get_pkcs5_iteration_count(thid, benchmarkPim, benchmarkPreBoot), dk, MASTER_KEYDATA_SIZE);
 					break;
 				}
 	                   #endif	
                         }
 
 			if (QueryPerformanceCounter (&performanceCountEnd) == 0)
 				goto counter_error;
 
 			benchmarkTable[benchmarkTotalItems].encSpeed = performanceCountEnd.QuadPart - performanceCountStart.QuadPart;
 			benchmarkTable[benchmarkTotalItems].id = thid;
 			benchmarkTable[benchmarkTotalItems].decSpeed = get_pkcs5_iteration_count(thid, benchmarkPim, benchmarkPreBoot);
 			benchmarkTable[benchmarkTotalItems].meanBytesPerSec = (unsigned __int64) (1000 * ((float) benchmarkTable[benchmarkTotalItems].encSpeed / benchmarkPerformanceFrequency.QuadPart / 2));
 			if (benchmarkPreBoot)
 			{
 				/* heuristics for boot times */
 				if (benchmarkGPT)
 				{
 					benchmarkTable[benchmarkTotalItems].meanBytesPerSec = (benchmarkTable[benchmarkTotalItems].meanBytesPerSec * 8) / 5;
 				}
 				else
 				{
 					if (thid == SHA256)
 					{
 #ifdef  _WIN64
 						benchmarkTable[benchmarkTotalItems].meanBytesPerSec = (benchmarkTable[benchmarkTotalItems].meanBytesPerSec * 26);
 #else
 						benchmarkTable[benchmarkTotalItems].meanBytesPerSec = (benchmarkTable[benchmarkTotalItems].meanBytesPerSec * 24);
 #endif
 					}
 					else
@@ -7612,61 +7607,61 @@ CipherTestDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
 					for (ci->ea = EAGetFirst (); ci->ea != 0 ; ci->ea = EAGetNext (ci->ea))
 						if (EAGetCipherCount (ci->ea) == 1 && EAGetFirstCipher (ci->ea) == idTestCipher)
 							break;
 
 					if ((tmpRetVal = EAInit (ci->ea, (unsigned char *) key, ci->ks)) != ERR_SUCCESS)
 					{
 						handleError (hwndDlg, tmpRetVal, SRC_POS);
 						crypto_close (ci);
 						return 1;
 					}
 
 					memcpy (&ci->k2, secondaryKey, sizeof (secondaryKey));
 					if (!EAInitMode (ci, ci->k2))
 					{
 						crypto_close (ci);
 						return 1;
 					}
 
 					structDataUnitNo.Value = BE64(((unsigned __int64 *)dataUnitNo)[0]);
 
 					if (bEncrypt)
 						EncryptBufferXTS ((unsigned char *) tmp, pt, &structDataUnitNo, blockNo, (unsigned char *) (ci->ks), (unsigned char *) ci->ks2, idTestCipher);
 					else
 						DecryptBufferXTS ((unsigned char *) tmp, pt, &structDataUnitNo, blockNo, (unsigned char *) (ci->ks), (unsigned char *) ci->ks2, idTestCipher);
 
 					crypto_close (ci);
 				}
 				else
 				{
 
-					CipherInit2(idTestCipher, key, ks_tmp, ks);
+					CipherInit2(idTestCipher, key, ks_tmp);
 
 					if (bEncrypt)
 					{
 						EncipherBlock(idTestCipher, tmp, ks_tmp);
 					}
 					else
 					{
 						DecipherBlock(idTestCipher, tmp, ks_tmp);
 					}
 
 				}
 				*szTmp = 0;
 
 				for (n = 0; n < pt; n ++)
 				{
 					wchar_t szTmp2[3];
 					StringCbPrintfW(szTmp2, sizeof(szTmp2), L"%02x", (int)((unsigned char)tmp[n]));
 					StringCbCatW(szTmp, sizeof(szTmp), szTmp2);
 				}
 
 				if (bEncrypt)
 					SetWindowText(GetDlgItem(hwndDlg,IDC_CIPHERTEXT), szTmp);
 				else
 					SetWindowText(GetDlgItem(hwndDlg,IDC_PLAINTEXT), szTmp);
 			}
 
 			return 1;
 		}
 
 		if (lw == IDCLOSE || lw == IDCANCEL)
@@ -11453,61 +11448,61 @@ BYTE *MapResource (wchar_t *resourceType, int resourceId, PDWORD size)
 	return (BYTE *) LockResource (hResL);
 }
 
 
 void InconsistencyResolved (char *techInfo)
 {
 	wchar_t finalMsg[8024];
 
 	StringCbPrintfW (finalMsg, sizeof(finalMsg), GetString ("INCONSISTENCY_RESOLVED"), techInfo);
 	MessageBoxW (MainDlg, finalMsg, lpszTitle, MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST);
 }
 
 
 void ReportUnexpectedState (const char *techInfo)
 {
 	wchar_t finalMsg[8024];
 
 	StringCbPrintfW (finalMsg, sizeof(finalMsg), GetString ("UNEXPECTED_STATE"), techInfo);
 	MessageBoxW (MainDlg, finalMsg, lpszTitle, MB_ICONERROR | MB_SETFOREGROUND | MB_TOPMOST);
 }
 
 
 #ifndef SETUP
 
 int OpenVolume (OpenVolumeContext *context, const wchar_t *volumePath, Password *password, int pkcs5_prf, int pim, BOOL write, BOOL preserveTimestamps, BOOL useBackupHeader)
 {
 	int status = ERR_PARAMETER_INCORRECT;
 	int volumeType;
 	wchar_t szDiskFile[TC_MAX_PATH], szCFDevice[TC_MAX_PATH];
 	wchar_t szDosDevice[TC_MAX_PATH];
-	char buffer[TC_VOLUME_HEADER_EFFECTIVE_SIZE];
+	unsigned char buffer[TC_VOLUME_HEADER_EFFECTIVE_SIZE];
 	LARGE_INTEGER headerOffset;
 	DWORD dwResult;
 	DISK_GEOMETRY_EX deviceGeometry;
 
 	context->VolumeIsOpen = FALSE;
 	context->CryptoInfo = NULL;
 	context->HostFileHandle = INVALID_HANDLE_VALUE;
 	context->TimestampsValid = FALSE;
 
 	CreateFullVolumePath (szDiskFile, sizeof(szDiskFile), volumePath, &context->IsDevice);
 
 	if (context->IsDevice)
 	{
 		status = FakeDosNameForDevice (szDiskFile, szDosDevice, sizeof(szDosDevice), szCFDevice, sizeof(szCFDevice), FALSE);
 		if (status != 0)
 			return status;
 
 		preserveTimestamps = FALSE;
 
 		if (!GetDriveGeometry (volumePath, &deviceGeometry))
 		{
 			status = ERR_OS_ERROR;
 			goto error;
 		}
 	}
 	else
 		StringCbCopyW (szCFDevice, sizeof(szCFDevice), szDiskFile);
 
 
 	context->HostFileHandle = CreateFile (szCFDevice, GENERIC_READ | (write ? GENERIC_WRITE : (!context->IsDevice && preserveTimestamps? FILE_WRITE_ATTRIBUTES : 0)), FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
@@ -11667,61 +11662,61 @@ error:
 
 	SetLastError (sysError);
 	return status;
 }
 
 
 void CloseVolume (OpenVolumeContext *context)
 {
 	if (!context->VolumeIsOpen)
 		return;
 
 	if (context->HostFileHandle != INVALID_HANDLE_VALUE)
 	{
 		if (context->TimestampsValid)
 			SetFileTime (context->HostFileHandle, &context->CreationTime, &context->LastAccessTime, &context->LastWriteTime);
 
 		CloseHandle (context->HostFileHandle);
 		context->HostFileHandle = INVALID_HANDLE_VALUE;
 	}
 
 	if (context->CryptoInfo)
 	{
 		crypto_close (context->CryptoInfo);
 		context->CryptoInfo = NULL;
 	}
 
 	context->VolumeIsOpen = FALSE;
 }
 
 
-int ReEncryptVolumeHeader (HWND hwndDlg, char *buffer, BOOL bBoot, CRYPTO_INFO *cryptoInfo, Password *password, int pim, BOOL wipeMode)
+int ReEncryptVolumeHeader (HWND hwndDlg, unsigned char *buffer, BOOL bBoot, CRYPTO_INFO *cryptoInfo, Password *password, int pim, BOOL wipeMode)
 {
 	CRYPTO_INFO *newCryptoInfo = NULL;
 
 	RandSetHashFunction (cryptoInfo->pkcs5);
 
 	if (Randinit() != ERR_SUCCESS)
 	{
 		if (CryptoAPILastError == ERROR_SUCCESS)
 			return ERR_RAND_INIT_FAILED;
 		else
 			return ERR_CAPI_INIT_FAILED;
 	}
 
 	UserEnrichRandomPool (NULL);
 
 	int status = CreateVolumeHeaderInMemory (hwndDlg, bBoot,
 		buffer,
 		cryptoInfo->ea,
 		cryptoInfo->mode,
 		password,
 		cryptoInfo->pkcs5,
 		pim,
 		(char *) cryptoInfo->master_keydata,
 		&newCryptoInfo,
 		cryptoInfo->VolumeSize.Value,
 		cryptoInfo->hiddenVolume ? cryptoInfo->hiddenVolumeSize : 0,
 		cryptoInfo->EncryptedAreaStart.Value,
 		cryptoInfo->EncryptedAreaLength.Value,
 		cryptoInfo->RequiredProgramVersion,
 		cryptoInfo->HeaderFlags,