1 files changed, 312 insertions, 25 deletions
diff --git a/src/Common/Dlgcode.c b/src/Common/Dlgcode.c
index 2cf5bb8e..6958afe9 100644
--- a/src/Common/Dlgcode.c
+++ b/src/Common/Dlgcode.c
@@ -248,6 +248,9 @@ typedef LSTATUS (STDAPICALLTYPE *SHDeleteKeyWPtr)(HKEY hkey, LPCWSTR pszSubKey);
 
 typedef HRESULT (STDAPICALLTYPE *SHStrDupWPtr)(LPCWSTR psz, LPWSTR *ppwsz);
 
+// ChangeWindowMessageFilter
+typedef BOOL (WINAPI *ChangeWindowMessageFilterPtr) (UINT, DWORD);
+
 ImageList_CreatePtr ImageList_CreateFn = NULL;
 ImageList_AddPtr ImageList_AddFn = NULL;
 
@@ -257,6 +260,7 @@ SetupInstallFromInfSectionWPtr SetupInstallFromInfSectionWFn = NULL;
 SetupOpenInfFileWPtr SetupOpenInfFileWFn = NULL;
 SHDeleteKeyWPtr SHDeleteKeyWFn = NULL;
 SHStrDupWPtr SHStrDupWFn = NULL;
+ChangeWindowMessageFilterPtr ChangeWindowMessageFilterFn = NULL;
 
 /* Windows dialog class */
 #define WINDOWS_DIALOG_CLASS L"#32770"
@@ -265,6 +269,16 @@ SHStrDupWPtr SHStrDupWFn = NULL;
 #define TC_DLG_CLASS L"VeraCryptCustomDlg"
 #define TC_SPLASH_CLASS L"VeraCryptSplashDlg"
 
+/* constant used by ChangeWindowMessageFilter calls */
+#ifndef MSGFLT_ADD
+#define MSGFLT_ADD	1
+#endif
+
+/* undocumented message sent during drag-n-drop */
+#ifndef WM_COPYGLOBALDATA
+#define WM_COPYGLOBALDATA 0x0049
+#endif
+
 /* Benchmarks */
 
 #ifndef SETUP
@@ -2603,6 +2617,19 @@ void InitApp (HINSTANCE hInstance, wchar_t *lpszCommandLine)
 	if (!SHDeleteKeyWFn || !SHStrDupWFn)
 		AbortProcess ("INIT_DLL");
 
+	if (IsOSAtLeast (WIN_VISTA))
+	{
+		/* Get ChangeWindowMessageFilter used to enable some messages bypasss UIPI (User Interface Privilege Isolation) */
+		ChangeWindowMessageFilterFn = (ChangeWindowMessageFilterPtr) GetProcAddress (GetModuleHandle (L"user32.dll"), "ChangeWindowMessageFilter");
+
+#ifndef SETUP
+		/* enable drag-n-drop when we are running elevated */
+		AllowMessageInUIPI (WM_DROPFILES);
+		AllowMessageInUIPI (WM_COPYDATA);
+		AllowMessageInUIPI (WM_COPYGLOBALDATA);
+#endif
+	}
+
 	/* Save the instance handle for later */
 	hInst = hInstance;
 
@@ -2903,7 +2930,7 @@ void InitHelpFileName (void)
 	}
 }
 
-BOOL OpenDevice (const wchar_t *lpszPath, OPEN_TEST_STRUCT *driver, BOOL detectFilesystem)
+BOOL OpenDevice (const wchar_t *lpszPath, OPEN_TEST_STRUCT *driver, BOOL detectFilesystem, BOOL matchVolumeID, const BYTE* pbVolumeID)
 {
 	DWORD dwResult;
 	BOOL bResult;
@@ -2916,6 +2943,9 @@ BOOL OpenDevice (const wchar_t *lpszPath, OPEN_TEST_STRUCT *driver, BOOL detectF
 
 	driver->bDetectTCBootLoader = FALSE;
 	driver->DetectFilesystem = detectFilesystem;
+	driver->bMatchVolumeID = matchVolumeID;
+	if (matchVolumeID && pbVolumeID)
+		memcpy (driver->volumeID, pbVolumeID, VOLUME_ID_SIZE);
 
 	bResult = DeviceIoControl (hDriver, TC_IOCTL_OPEN_TEST,
 				   driver, sizeof (OPEN_TEST_STRUCT),
@@ -2943,6 +2973,7 @@ BOOL OpenDevice (const wchar_t *lpszPath, OPEN_TEST_STRUCT *driver, BOOL detectF
 		{
 			driver->TCBootLoaderDetected = FALSE;
 			driver->FilesystemDetected = FALSE;
+			driver->VolumeIDMatched = FALSE;
 			return TRUE;
 		}
 		else
@@ -4685,6 +4716,55 @@ wstring IntToWideString (int val)
 	return szTmp;
 }
 
+wstring ArrayToHexWideString (const unsigned char* pbData, int cbData)
+{
+	static wchar_t* hexChar = L"0123456789ABCDEF";
+	wstring result;
+	if (pbData)
+	{
+		for (int i = 0; i < cbData; i++)
+		{
+			result += hexChar[pbData[i] >> 4];
+			result += hexChar[pbData[i] & 0x0F];
+		}
+	}
+
+	return result;
+}
+
+bool HexToByte (wchar_t c, byte& b)
+{
+	bool bRet = true;
+	if (c >= L'0' && c <= L'9')
+		b = (byte) (c - L'0');
+	else if (c >= L'a' && c <= L'z')
+		b = (byte) (c - L'a' + 10);
+	else if (c >= L'A' && c <= L'Z')
+		b = (byte) (c - L'A' + 10);
+	else
+		bRet = false;
+
+	return bRet;
+}
+
+bool HexWideStringToArray (const wchar_t* hexStr, std::vector<byte>& arr)
+{
+	byte b1, b2;
+	size_t i, len = wcslen (hexStr);
+
+	arr.clear();
+	if (len %2)
+		return false;
+	
+	for (i = 0; i < len/2; i++)
+	{
+		if (!HexToByte (*hexStr++, b1) || !HexToByte (*hexStr++, b2))
+			return false;
+		arr.push_back (b1 << 4 | b2);
+	}
+	return true;
+}
+
 wstring GetTempPathString ()
 {
 	wchar_t tempPath[MAX_PATH];
@@ -6680,11 +6760,13 @@ DWORD GetUsedLogicalDrives (void)
 int GetFirstAvailableDrive ()
 {
 	DWORD dwUsedDrives = GetUsedLogicalDrives();
-	int i;
+	int i, drive;
 
-	for (i = 0; i < 26; i++)
+	/* let A: and B: be used as last resort since they can introduce side effects */
+	for (i = 2; i < 28; i++)
 	{
-		if (!(dwUsedDrives & 1 << i))
+		drive = (i < 26) ? i : (i - 26);
+		if (!(dwUsedDrives & 1 << drive))
 			return i;
 	}
 
@@ -7042,12 +7124,37 @@ void ShowWaitDialog(HWND hwnd, BOOL bUseHwndAsParent, WaitThreadProc callback, v
 
 /************************************************************************/
 
+static BOOL PerformMountIoctl (MOUNT_STRUCT* pmount, LPDWORD pdwResult, BOOL useVolumeID, BYTE volumeID[VOLUME_ID_SIZE])
+{
+	if (useVolumeID)
+	{
+		wstring devicePath = FindDeviceByVolumeID (volumeID);
+		if (devicePath == L"")
+		{
+			if (pdwResult)
+				*pdwResult = 0;
+			SetLastError (ERROR_PATH_NOT_FOUND);
+			return FALSE;
+		}
+		else
+		{
+			BOOL bDevice = FALSE;
+			CreateFullVolumePath (pmount->wszVolume, sizeof(pmount->wszVolume), devicePath.c_str(), &bDevice);
+		}
+	}
+	
+	return DeviceIoControl (hDriver, TC_IOCTL_MOUNT_VOLUME, pmount,
+			sizeof (MOUNT_STRUCT), pmount, sizeof (MOUNT_STRUCT), pdwResult, NULL);
+}
+
 // specific definitions and implementation for support of mount operation 
 // in wait dialog mechanism
 
 typedef struct
 {
 	MOUNT_STRUCT* pmount;
+	BOOL useVolumeID;
+	BYTE volumeID[VOLUME_ID_SIZE];
 	BOOL* pbResult;
 	DWORD* pdwResult;
 	DWORD dwLastError;
@@ -7057,8 +7164,7 @@ void CALLBACK MountWaitThreadProc(void* pArg, HWND )
 {
 	MountThreadParam* pThreadParam = (MountThreadParam*) pArg;
 
-	*(pThreadParam->pbResult) = DeviceIoControl (hDriver, TC_IOCTL_MOUNT_VOLUME, pThreadParam->pmount,
-		sizeof (MOUNT_STRUCT),pThreadParam->pmount, sizeof (MOUNT_STRUCT), pThreadParam->pdwResult, NULL);
+	*(pThreadParam->pbResult) = PerformMountIoctl (pThreadParam->pmount, pThreadParam->pdwResult, pThreadParam->useVolumeID, pThreadParam->volumeID);
 
 	pThreadParam->dwLastError = GetLastError ();
 }
@@ -7095,6 +7201,8 @@ int MountVolume (HWND hwndDlg,
 	BOOL bResult, bDevice;
 	wchar_t root[MAX_PATH];
 	int favoriteMountOnArrivalRetryCount = 0;
+	BOOL useVolumeID = FALSE;
+	BYTE volumeID[VOLUME_ID_SIZE] = {0};
 
 #ifdef TCMOUNT
 	if (mountOptions->PartitionInInactiveSysEncScope)
@@ -7181,7 +7289,29 @@ retry:
 			StringCchCopyW (volumePath, TC_MAX_PATH, resolvedPath.c_str());
 	}
 
-	CreateFullVolumePath (mount.wszVolume, sizeof(mount.wszVolume), volumePath, &bDevice);
+	if ((path.length () >= 3) && (_wcsnicmp (path.c_str(), L"ID:", 3) == 0))
+	{
+		std::vector<byte> arr;
+		if (	(path.length() == (3 + 2*VOLUME_ID_SIZE)) 
+			&& HexWideStringToArray (path.c_str() + 3, arr)
+			&& (arr.size() == VOLUME_ID_SIZE)
+			)
+		{
+			useVolumeID = TRUE;
+			bDevice = TRUE;
+			memcpy (volumeID, &arr[0], VOLUME_ID_SIZE);
+		}
+		else
+		{
+			if (!quiet)
+				Error ("VOLUME_ID_INVALID", hwndDlg);
+
+			SetLastError (ERROR_INVALID_PARAMETER);
+			return -1;
+		}
+	}
+	else
+		CreateFullVolumePath (mount.wszVolume, sizeof(mount.wszVolume), volumePath, &bDevice);
 
 	if (!bDevice)
 	{
@@ -7257,6 +7387,8 @@ retry:
 	{
 		MountThreadParam mountThreadParam;
 		mountThreadParam.pmount = &mount;
+		mountThreadParam.useVolumeID = useVolumeID;
+		memcpy (mountThreadParam.volumeID, volumeID, VOLUME_ID_SIZE);
 		mountThreadParam.pbResult = &bResult;
 		mountThreadParam.pdwResult = &dwResult;
 		mountThreadParam.dwLastError = ERROR_SUCCESS;
@@ -7267,8 +7399,8 @@ retry:
 	}
 	else
 	{
-		bResult = DeviceIoControl (hDriver, TC_IOCTL_MOUNT_VOLUME, &mount,
-				sizeof (mount), &mount, sizeof (mount), &dwResult, NULL);
+		bResult = PerformMountIoctl (&mount, &dwResult, useVolumeID, volumeID);
+
 		dwLastError = GetLastError ();
 	}
 
@@ -7555,22 +7687,11 @@ BOOL IsPasswordCacheEmpty (void)
 	return !DeviceIoControl (hDriver, TC_IOCTL_GET_PASSWORD_CACHE_STATUS, 0, 0, 0, 0, &dw, 0);
 }
 
-
-BOOL IsMountedVolume (const wchar_t *volname)
+BOOL IsMountedVolumeID (BYTE volumeID[VOLUME_ID_SIZE])
 {
 	MOUNT_LIST_STRUCT mlist;
 	DWORD dwResult;
 	int i;
-	wchar_t volume[TC_MAX_PATH*2+16];
-
-	StringCbCopyW (volume, sizeof(volume), volname);
-
-	if (wcsstr (volname, L"\\Device\\") != volname)
-		StringCbPrintfW(volume, sizeof(volume), L"\\??\\%s", volname);
-
-	wstring resolvedPath = VolumeGuidPathToDevicePath (volname);
-	if (!resolvedPath.empty())
-		StringCbCopyW (volume, sizeof (volume), resolvedPath.c_str());
 
 	memset (&mlist, 0, sizeof (mlist));
 	DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, &mlist,
@@ -7578,12 +7699,52 @@ BOOL IsMountedVolume (const wchar_t *volname)
 		NULL);
 
 	for (i=0 ; i<26; i++)
-		if (0 == _wcsicmp ((wchar_t *) mlist.wszVolume[i], volume))
+		if (0 == memcmp (mlist.volumeID[i], volumeID, VOLUME_ID_SIZE))
 			return TRUE;
 
 	return FALSE;
 }
 
+BOOL IsMountedVolume (const wchar_t *volname)
+{
+	if ((wcslen (volname) == (3 + 2*VOLUME_ID_SIZE)) && _wcsnicmp (volname, L"ID:", 3) == 0)
+	{
+		/* Volume ID specified. Use it for matching mounted volumes. */
+		std::vector<byte> arr;
+		if (HexWideStringToArray (&volname[3], arr) && (arr.size() == VOLUME_ID_SIZE))
+		{
+			return IsMountedVolumeID (&arr[0]);
+		}
+	}
+	else
+	{
+		MOUNT_LIST_STRUCT mlist;
+		DWORD dwResult;
+		int i;
+		wchar_t volume[TC_MAX_PATH*2+16];
+
+		StringCbCopyW (volume, sizeof(volume), volname);
+
+		if (wcsstr (volname, L"\\Device\\") != volname)
+			StringCbPrintfW(volume, sizeof(volume), L"\\??\\%s", volname);
+
+		wstring resolvedPath = VolumeGuidPathToDevicePath (volname);
+		if (!resolvedPath.empty())
+			StringCbCopyW (volume, sizeof (volume), resolvedPath.c_str());
+
+		memset (&mlist, 0, sizeof (mlist));
+		DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, &mlist,
+			sizeof (mlist), &mlist, sizeof (mlist), &dwResult,
+			NULL);
+
+		for (i=0 ; i<26; i++)
+			if (0 == _wcsicmp ((wchar_t *) mlist.wszVolume[i], volume))
+				return TRUE;
+	}
+
+	return FALSE;
+}
+
 
 int GetMountedVolumeDriveNo (wchar_t *volname)
 {
@@ -10848,7 +11009,7 @@ std::vector <HostDevice> GetAvailableHostDevices (bool noDeviceProperties, bool
 			const wchar_t *devPath = devPathStr.c_str();
 
 			OPEN_TEST_STRUCT openTest = {0};
-			if (!OpenDevice (devPath, &openTest, detectUnencryptedFilesystems && partNumber != 0))
+			if (!OpenDevice (devPath, &openTest, detectUnencryptedFilesystems && partNumber != 0, FALSE, NULL))
 			{
 				if (partNumber == 0)
 					break;
@@ -10953,7 +11114,7 @@ std::vector <HostDevice> GetAvailableHostDevices (bool noDeviceProperties, bool
 			const wchar_t *devPath = devPathStr.c_str();
 
 			OPEN_TEST_STRUCT openTest = {0};
-			if (!OpenDevice (devPath, &openTest, detectUnencryptedFilesystems))
+			if (!OpenDevice (devPath, &openTest, detectUnencryptedFilesystems, FALSE, NULL))
 				continue;
 
 			DISK_PARTITION_INFO_STRUCT info;
@@ -10993,6 +11154,46 @@ std::vector <HostDevice> GetAvailableHostDevices (bool noDeviceProperties, bool
 	return devices;
 }
 
+wstring FindDeviceByVolumeID (const BYTE volumeID [VOLUME_ID_SIZE])
+{
+	/* if it is already mounted, get the real path name used for mounting */
+	MOUNT_LIST_STRUCT mlist;
+	DWORD dwResult;
+
+	memset (&mlist, 0, sizeof (mlist));
+	DeviceIoControl (hDriver, TC_IOCTL_GET_MOUNTED_VOLUMES, &mlist,
+		sizeof (mlist), &mlist, sizeof (mlist), &dwResult,
+		NULL);
+
+	for (int i=0 ; i < 26; i++)
+	{
+		if (0 == memcmp (mlist.volumeID[i], volumeID, VOLUME_ID_SIZE))
+			return mlist.wszVolume[i];
+	}
+
+	/* not mounted. Look for it in the local drives*/
+	for (int devNumber = 0; devNumber < MAX_HOST_DRIVE_NUMBER; devNumber++)
+	{
+		for (int partNumber = 0; partNumber < MAX_HOST_PARTITION_NUMBER; partNumber++)
+		{
+			wstringstream strm;
+			strm << L"\\Device\\Harddisk" << devNumber << L"\\Partition" << partNumber;
+			wstring devPathStr (strm.str());
+			const wchar_t *devPath = devPathStr.c_str();
+
+			OPEN_TEST_STRUCT openTest = {0};
+			if (!OpenDevice (devPath, &openTest, FALSE, TRUE, volumeID))
+			{
+				continue;
+			}
+
+			if (openTest.VolumeIDMatched)
+				return devPath;
+		}
+	}
+
+	return L"";
+}
 
 BOOL FileHasReadOnlyAttribute (const wchar_t *path)
 {
@@ -11215,7 +11416,7 @@ BOOL VolumePathExists (const wchar_t *volumePath)
 	UpperCaseCopy (upperCasePath, sizeof(upperCasePath), volumePath);
 
 	if (wcsstr (upperCasePath, L"\\DEVICE\\") == upperCasePath)
-		return OpenDevice (volumePath, &openTest, FALSE);
+		return OpenDevice (volumePath, &openTest, FALSE, FALSE, NULL);
 
 	wstring path = volumePath;
 	if (path.find (L"\\\\?\\Volume{") == 0 && path.rfind (L"}\\") == path.size() - 2)
@@ -11575,3 +11776,89 @@ void ProcessEntropyEstimate (HWND hProgress, DWORD* pdwInitialValue, DWORD dwCou
 		0);
 	}
 }
+
+void AllowMessageInUIPI (UINT msg)
+{
+	if (ChangeWindowMessageFilterFn)
+	{
+		ChangeWindowMessageFilterFn (msg, MSGFLT_ADD);
+	}
+}
+
+BOOL IsRepeatedByteArray (byte value, const byte* buffer, size_t bufferSize)
+{
+	if (buffer && bufferSize)
+	{
+		size_t i;
+		for (i = 0; i < bufferSize; i++)
+		{
+			if (*buffer++ != value)
+				return FALSE;
+		}
+		return TRUE;
+	}
+	else
+		return FALSE;
+}
+
+BOOL TranslateVolumeID (HWND hwndDlg, wchar_t* pathValue, size_t cchPathValue)
+{
+	BOOL bRet = TRUE;
+	size_t pathLen = pathValue? wcslen (pathValue) : 0;
+	if ((pathLen >= 3) && (_wcsnicmp (pathValue, L"ID:", 3) == 0))
+	{
+		std::vector<byte> arr;
+		if (	(pathLen == (3 + 2*VOLUME_ID_SIZE)) 
+			&& HexWideStringToArray (pathValue + 3, arr)
+			&& (arr.size() == VOLUME_ID_SIZE)
+			)
+		{
+			std::wstring devicePath = FindDeviceByVolumeID (&arr[0]);
+			if (devicePath.length() > 0)
+				StringCchCopyW (pathValue, cchPathValue, devicePath.c_str());
+			else
+			{
+				if (!Silent && !MultipleMountOperationInProgress)
+					Error ("VOLUME_ID_NOT_FOUND", hwndDlg);
+				SetLastError (ERROR_PATH_NOT_FOUND);
+				bRet = FALSE;
+			}
+		}
+		else
+		{
+			if (!Silent)
+				Error ("VOLUME_ID_INVALID", hwndDlg);
+
+			SetLastError (ERROR_INVALID_PARAMETER);
+			bRet = FALSE;
+		}
+	}
+	
+	return bRet;
+}
+
+BOOL CopyTextToClipboard (LPCWSTR txtValue)
+{
+	size_t txtLen = wcslen(txtValue);
+	HGLOBAL hdst;
+	LPWSTR dst;
+	BOOL bRet = FALSE;
+
+	// Allocate string for cwd
+	hdst = GlobalAlloc(GMEM_MOVEABLE, (txtLen + 1) * sizeof(WCHAR));
+	if (hdst)
+	{
+		dst = (LPWSTR)GlobalLock(hdst);
+		wmemcpy(dst, txtValue, txtLen + 1);
+		GlobalUnlock(hdst);
+
+		if (OpenClipboard(NULL))
+		{
+			EmptyClipboard();
+			SetClipboardData(CF_UNICODETEXT, hdst);
+			CloseClipboard();
+		}
+	}
+
+	return bRet;
+}