nihilist/VeraCrypt
1
0
Fork 0
mirror of https://github.com/veracrypt/VeraCrypt synced 2024-12-03 16:33:30 +01:00
Code Issues Packages Projects Releases Wiki Activity

Windows: Finalize implementation of the new volume ID mechanism. Use SHA-256 instead of SHA-512 to compute volume ID to reduce string size and make more convenient to use.

Browse Source
This commit is contained in:
Mounir IDRASSI 2016-04-14 08:52:06 +02:00
parent 60575d9a49
commit f5606a44a6
12 changed files with 416 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/Common/Apidrvr.h
View File

@ -128,7 +128,7 @@ typedef struct
unsigned __int32 ulMountedDrives; /* Bitfield of all mounted drive letters */ unsigned __int32 ulMountedDrives; /* Bitfield of all mounted drive letters */
wchar_t wszVolume[26][TC_MAX_PATH]; /* Volume names of mounted volumes */ wchar_t wszVolume[26][TC_MAX_PATH]; /* Volume names of mounted volumes */
wchar_t wszLabel[26][33]; /* Labels of mounted volumes */ wchar_t wszLabel[26][33]; /* Labels of mounted volumes */
wchar_t volumeID[26][SHA512_DIGEST_SIZE]; /* IDs of mounted volumes */ wchar_t volumeID[26][VOLUME_ID_SIZE]; /* IDs of mounted volumes */
unsigned __int64 diskLength[26]; unsigned __int64 diskLength[26];
int ea[26]; int ea[26];
int volumeType[26]; /* Volume type (e.g. PROP_VOL_TYPE_OUTER, PROP_VOL_TYPE_OUTER_VOL_WRITE_PREVENTED, etc.) */ int volumeType[26]; /* Volume type (e.g. PROP_VOL_TYPE_OUTER, PROP_VOL_TYPE_OUTER_VOL_WRITE_PREVENTED, etc.) */
@ -157,7 +157,7 @@ typedef struct
int volumePim; int volumePim;
wchar_t wszLabel[33]; wchar_t wszLabel[33];
BOOL bDriverSetLabel; BOOL bDriverSetLabel;
unsigned char volumeID[SHA512_DIGESTSIZE]; unsigned char volumeID[VOLUME_ID_SIZE];
} VOLUME_PROPERTIES_STRUCT; } VOLUME_PROPERTIES_STRUCT;
typedef struct typedef struct
@ -197,7 +197,7 @@ typedef struct
BOOL DetectFilesystem; BOOL DetectFilesystem;
BOOL FilesystemDetected; BOOL FilesystemDetected;
BOOL bMatchVolumeID; BOOL bMatchVolumeID;
unsigned char volumeID[SHA512_DIGEST_SIZE]; unsigned char volumeID[VOLUME_ID_SIZE];
BOOL VolumeIDMatched; BOOL VolumeIDMatched;
} OPEN_TEST_STRUCT; } OPEN_TEST_STRUCT;

2
src/Common/Common.h
View File

@ -21,6 +21,8 @@
#define MAX_HOST_DRIVE_NUMBER 64 #define MAX_HOST_DRIVE_NUMBER 64
#define MAX_HOST_PARTITION_NUMBER 32 #define MAX_HOST_PARTITION_NUMBER 32
#define VOLUME_ID_SIZE SHA256_DIGESTSIZE
typedef enum typedef enum
{ {
// IMPORTANT: If you add a new item here, update IsOSVersionAtLeast(). // IMPORTANT: If you add a new item here, update IsOSVersionAtLeast().

143
src/Common/Dlgcode.c
View File

@ -2930,7 +2930,7 @@ void InitHelpFileName (void)
} }
} }
BOOL OpenDevice (const wchar_t *lpszPath, OPEN_TEST_STRUCT *driver, BOOL detectFilesystem, BOOL matchVolumeID, BYTE* pbVolumeID) BOOL OpenDevice (const wchar_t *lpszPath, OPEN_TEST_STRUCT *driver, BOOL detectFilesystem, BOOL matchVolumeID, const BYTE* pbVolumeID)
{ {
DWORD dwResult; DWORD dwResult;
BOOL bResult; BOOL bResult;
@ -2945,7 +2945,7 @@ BOOL OpenDevice (const wchar_t *lpszPath, OPEN_TEST_STRUCT *driver, BOOL detectF
driver->DetectFilesystem = detectFilesystem; driver->DetectFilesystem = detectFilesystem;
driver->bMatchVolumeID = matchVolumeID; driver->bMatchVolumeID = matchVolumeID;
if (matchVolumeID && pbVolumeID) if (matchVolumeID && pbVolumeID)
memcpy (driver->volumeID, pbVolumeID, SHA512_DIGEST_SIZE); memcpy (driver->volumeID, pbVolumeID, VOLUME_ID_SIZE);
bResult = DeviceIoControl (hDriver, TC_IOCTL_OPEN_TEST, bResult = DeviceIoControl (hDriver, TC_IOCTL_OPEN_TEST,
driver, sizeof (OPEN_TEST_STRUCT), driver, sizeof (OPEN_TEST_STRUCT),
@ -2973,6 +2973,7 @@ BOOL OpenDevice (const wchar_t *lpszPath, OPEN_TEST_STRUCT *driver, BOOL detectF
{ {
driver->TCBootLoaderDetected = FALSE; driver->TCBootLoaderDetected = FALSE;
driver->FilesystemDetected = FALSE; driver->FilesystemDetected = FALSE;
driver->VolumeIDMatched = FALSE;
return TRUE; return TRUE;
} }
else else
@ -7121,7 +7122,7 @@ void ShowWaitDialog(HWND hwnd, BOOL bUseHwndAsParent, WaitThreadProc callback, v
/************************************************************************/ /************************************************************************/
static BOOL PerformMountIoctl (MOUNT_STRUCT* pmount, LPDWORD pdwResult, BOOL useVolumeID, BYTE volumeID[SHA512_DIGEST_SIZE]) static BOOL PerformMountIoctl (MOUNT_STRUCT* pmount, LPDWORD pdwResult, BOOL useVolumeID, BYTE volumeID[VOLUME_ID_SIZE])
{ {
if (useVolumeID) if (useVolumeID)
{ {
@ -7151,7 +7152,7 @@ typedef struct
{ {
MOUNT_STRUCT* pmount; MOUNT_STRUCT* pmount;
BOOL useVolumeID; BOOL useVolumeID;
BYTE volumeID[SHA512_DIGEST_SIZE]; BYTE volumeID[VOLUME_ID_SIZE];
BOOL* pbResult; BOOL* pbResult;
DWORD* pdwResult; DWORD* pdwResult;
DWORD dwLastError; DWORD dwLastError;
@ -7199,7 +7200,7 @@ int MountVolume (HWND hwndDlg,
wchar_t root[MAX_PATH]; wchar_t root[MAX_PATH];
int favoriteMountOnArrivalRetryCount = 0; int favoriteMountOnArrivalRetryCount = 0;
BOOL useVolumeID = FALSE; BOOL useVolumeID = FALSE;
BYTE volumeID[SHA512_DIGEST_SIZE] = {0}; BYTE volumeID[VOLUME_ID_SIZE] = {0};
#ifdef TCMOUNT #ifdef TCMOUNT
if (mountOptions->PartitionInInactiveSysEncScope) if (mountOptions->PartitionInInactiveSysEncScope)
@ -7289,14 +7290,14 @@ int MountVolume (HWND hwndDlg,
if ((path.length () >= 3) && (_wcsnicmp (path.c_str(), L"ID:", 3) == 0)) if ((path.length () >= 3) && (_wcsnicmp (path.c_str(), L"ID:", 3) == 0))
{ {
std::vector<byte> arr; std::vector<byte> arr;
if ( (path.length() == (3 + 2*SHA512_DIGEST_SIZE)) if ( (path.length() == (3 + 2*VOLUME_ID_SIZE))
&& HexWideStringToArray (path.c_str() + 3, arr) && HexWideStringToArray (path.c_str() + 3, arr)
&& (arr.size() == SHA512_DIGEST_SIZE) && (arr.size() == VOLUME_ID_SIZE)
) )
{ {
useVolumeID = TRUE; useVolumeID = TRUE;
bDevice = TRUE; bDevice = TRUE;
memcpy (volumeID, &arr[0], SHA512_DIGEST_SIZE); memcpy (volumeID, &arr[0], VOLUME_ID_SIZE);
} }
else else
{ {
@ -7385,7 +7386,7 @@ int MountVolume (HWND hwndDlg,
MountThreadParam mountThreadParam; MountThreadParam mountThreadParam;
mountThreadParam.pmount = &mount; mountThreadParam.pmount = &mount;
mountThreadParam.useVolumeID = useVolumeID; mountThreadParam.useVolumeID = useVolumeID;
memcpy (mountThreadParam.volumeID, volumeID, SHA512_DIGESTSIZE); memcpy (mountThreadParam.volumeID, volumeID, VOLUME_ID_SIZE);
mountThreadParam.pbResult = &bResult; mountThreadParam.pbResult = &bResult;
mountThreadParam.pdwResult = &dwResult; mountThreadParam.pdwResult = &dwResult;
mountThreadParam.dwLastError = ERROR_SUCCESS; mountThreadParam.dwLastError = ERROR_SUCCESS;
@ -7684,8 +7685,7 @@ BOOL IsPasswordCacheEmpty (void)
return !DeviceIoControl (hDriver, TC_IOCTL_GET_PASSWORD_CACHE_STATUS, 0, 0, 0, 0, &dw, 0); return !DeviceIoControl (hDriver, TC_IOCTL_GET_PASSWORD_CACHE_STATUS, 0, 0, 0, 0, &dw, 0);
} }
BOOL IsMountedVolumeID (BYTE volumeID[VOLUME_ID_SIZE])
BOOL IsMountedVolume (const wchar_t *volname)
{ {
MOUNT_LIST_STRUCT mlist; MOUNT_LIST_STRUCT mlist;
DWORD dwResult; DWORD dwResult;
@ -7696,19 +7696,29 @@ BOOL IsMountedVolume (const wchar_t *volname)
sizeof (mlist), &mlist, sizeof (mlist), &dwResult, sizeof (mlist), &mlist, sizeof (mlist), &dwResult,
NULL); NULL);
if ((wcslen (volname) == (3 + 2*SHA512_DIGEST_SIZE)) && _wcsnicmp (volname, L"ID:", 3) == 0) for (i=0 ; i<26; i++)
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. */ /* Volume ID specified. Use it for matching mounted volumes. */
std::vector<byte> arr; std::vector<byte> arr;
if (HexWideStringToArray (&volname[3], arr) && (arr.size() == SHA512_DIGEST_SIZE)) if (HexWideStringToArray (&volname[3], arr) && (arr.size() == VOLUME_ID_SIZE))
{ {
for (i=0 ; i<26; i++) return IsMountedVolumeID (&arr[0]);
if (0 == memcmp (mlist.volumeID[i], &arr[0], SHA512_DIGEST_SIZE))
return TRUE;
} }
} }
else else
{ {
MOUNT_LIST_STRUCT mlist;
DWORD dwResult;
int i;
wchar_t volume[TC_MAX_PATH*2+16]; wchar_t volume[TC_MAX_PATH*2+16];
StringCbCopyW (volume, sizeof(volume), volname); StringCbCopyW (volume, sizeof(volume), volname);
@ -7720,6 +7730,11 @@ BOOL IsMountedVolume (const wchar_t *volname)
if (!resolvedPath.empty()) if (!resolvedPath.empty())
StringCbCopyW (volume, sizeof (volume), resolvedPath.c_str()); 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++) for (i=0 ; i<26; i++)
if (0 == _wcsicmp ((wchar_t *) mlist.wszVolume[i], volume)) if (0 == _wcsicmp ((wchar_t *) mlist.wszVolume[i], volume))
return TRUE; return TRUE;
@ -11137,8 +11152,24 @@ std::vector <HostDevice> GetAvailableHostDevices (bool noDeviceProperties, bool
return devices; return devices;
} }
wstring FindDeviceByVolumeID (BYTE volumeID [SHA512_DIGEST_SIZE]) 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 devNumber = 0; devNumber < MAX_HOST_DRIVE_NUMBER; devNumber++)
{ {
for (int partNumber = 0; partNumber < MAX_HOST_PARTITION_NUMBER; partNumber++) for (int partNumber = 0; partNumber < MAX_HOST_PARTITION_NUMBER; partNumber++)
@ -11382,23 +11413,6 @@ BOOL VolumePathExists (const wchar_t *volumePath)
UpperCaseCopy (upperCasePath, sizeof(upperCasePath), volumePath); UpperCaseCopy (upperCasePath, sizeof(upperCasePath), volumePath);
if (wcsstr (upperCasePath, L"ID:") == upperCasePath)
{
std::vector<byte> arr;
if ( (wcslen (upperCasePath) == (3 + 2*SHA512_DIGEST_SIZE))
&& HexWideStringToArray (&upperCasePath[3], arr)
&& (arr.size() == SHA512_DIGEST_SIZE)
)
{
if (FindDeviceByVolumeID (&arr[0]).length() > 0)
return TRUE;
else
return FALSE;
}
else
return FALSE;
}
if (wcsstr (upperCasePath, L"\\DEVICE\\") == upperCasePath) if (wcsstr (upperCasePath, L"\\DEVICE\\") == upperCasePath)
return OpenDevice (volumePath, &openTest, FALSE, FALSE, NULL); return OpenDevice (volumePath, &openTest, FALSE, FALSE, NULL);
@ -11785,3 +11799,64 @@ BOOL IsRepeatedByteArray (byte value, const byte* buffer, size_t bufferSize)
return FALSE; 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;
}

10
src/Common/Dlgcode.h
View File

@ -34,7 +34,8 @@ enum dynamic_gui_element_ids
IDPM_ADD_TO_FAVORITES, IDPM_ADD_TO_FAVORITES,
IDPM_ADD_TO_SYSTEM_FAVORITES, IDPM_ADD_TO_SYSTEM_FAVORITES,
IDM_SHOW_HIDE, IDM_SHOW_HIDE,
IDM_HOMEPAGE_SYSTRAY IDM_HOMEPAGE_SYSTRAY,
IDPM_COPY_VALUE_TO_CLIPBOARD
}; };
enum enum
@ -298,7 +299,7 @@ void InitOSVersionInfo ();
void InitApp ( HINSTANCE hInstance, wchar_t *lpszCommandLine ); void InitApp ( HINSTANCE hInstance, wchar_t *lpszCommandLine );
void FinalizeApp (void); void FinalizeApp (void);
void InitHelpFileName (void); void InitHelpFileName (void);
BOOL OpenDevice (const wchar_t *lpszPath, OPEN_TEST_STRUCT *driver, BOOL detectFilesystem, BOOL matchVolumeID, BYTE* pbVolumeID); BOOL OpenDevice (const wchar_t *lpszPath, OPEN_TEST_STRUCT *driver, BOOL detectFilesystem, BOOL matchVolumeID, const BYTE* pbVolumeID);
void NotifyDriverOfPortableMode (void); void NotifyDriverOfPortableMode (void);
int GetAvailableFixedDisks ( HWND hComboBox , char *lpszRootPath ); int GetAvailableFixedDisks ( HWND hComboBox , char *lpszRootPath );
int GetAvailableRemovables ( HWND hComboBox , char *lpszRootPath ); int GetAvailableRemovables ( HWND hComboBox , char *lpszRootPath );
@ -342,6 +343,7 @@ int MountVolume (HWND hwndDlg, int driveNo, wchar_t *volumePath, Password *passw
BOOL UnmountVolume (HWND hwndDlg , int nDosDriveNo, BOOL forceUnmount); BOOL UnmountVolume (HWND hwndDlg , int nDosDriveNo, BOOL forceUnmount);
BOOL UnmountVolumeAfterFormatExCall (HWND hwndDlg, int nDosDriveNo); BOOL UnmountVolumeAfterFormatExCall (HWND hwndDlg, int nDosDriveNo);
BOOL IsPasswordCacheEmpty (void); BOOL IsPasswordCacheEmpty (void);
BOOL IsMountedVolumeID (BYTE volumeID[VOLUME_ID_SIZE]);
BOOL IsMountedVolume (const wchar_t *volname); BOOL IsMountedVolume (const wchar_t *volname);
int GetMountedVolumeDriveNo (wchar_t *volname); int GetMountedVolumeDriveNo (wchar_t *volname);
BOOL IsAdmin (void); BOOL IsAdmin (void);
@ -502,6 +504,8 @@ HRESULT VCStrDupW(LPCWSTR psz, LPWSTR *ppwsz);
void ProcessEntropyEstimate (HWND hProgress, DWORD* pdwInitialValue, DWORD dwCounter, DWORD dwMaxLevel, DWORD* pdwEntropy); void ProcessEntropyEstimate (HWND hProgress, DWORD* pdwInitialValue, DWORD dwCounter, DWORD dwMaxLevel, DWORD* pdwEntropy);
void AllowMessageInUIPI (UINT msg); void AllowMessageInUIPI (UINT msg);
BOOL IsRepeatedByteArray (byte value, const byte* buffer, size_t bufferSize); BOOL IsRepeatedByteArray (byte value, const byte* buffer, size_t bufferSize);
BOOL TranslateVolumeID (HWND hwndDlg, wchar_t* pathValue, size_t cchPathValue);
BOOL CopyTextToClipboard (const wchar_t* txtValue);
#ifdef __cplusplus #ifdef __cplusplus
} }
@ -568,7 +572,7 @@ std::wstring GetUserFriendlyVersionString (int version);
std::wstring IntToWideString (int val); std::wstring IntToWideString (int val);
std::wstring ArrayToHexWideString (const unsigned char* pbData, int cbData); std::wstring ArrayToHexWideString (const unsigned char* pbData, int cbData);
bool HexWideStringToArray (const wchar_t* hexStr, std::vector<byte>& arr); bool HexWideStringToArray (const wchar_t* hexStr, std::vector<byte>& arr);
std::wstring FindDeviceByVolumeID (BYTE volumeID [SHA512_DIGEST_SIZE]); std::wstring FindDeviceByVolumeID (const BYTE volumeID [VOLUME_ID_SIZE]);
void RegisterDriverInf (bool registerFilter, const std::string& filter, const std::string& filterReg, HWND ParentWindow, HKEY regKey); void RegisterDriverInf (bool registerFilter, const std::string& filter, const std::string& filterReg, HWND ParentWindow, HKEY regKey);
std::wstring GetTempPathString (); std::wstring GetTempPathString ();
inline std::wstring AppendSrcPos (const wchar_t* msg, const char* srcPos) inline std::wstring AppendSrcPos (const wchar_t* msg, const char* srcPos)

5
src/Common/Language.xml
View File

@ -1388,9 +1388,12 @@
<string lang="en" key="INIT_DLL">Error: Failed to load a system library.</string> <string lang="en" key="INIT_DLL">Error: Failed to load a system library.</string>
<string lang="en" key="ERR_EXFAT_INVALID_VOLUME_SIZE">The volume file size specified in the command line is incompatible with selected exFAT filesystem.</string> <string lang="en" key="ERR_EXFAT_INVALID_VOLUME_SIZE">The volume file size specified in the command line is incompatible with selected exFAT filesystem.</string>
<control lang="en" key="IDT_ENTROPY_BAR">Randomness Collected From Mouse Movements</control> <control lang="en" key="IDT_ENTROPY_BAR">Randomness Collected From Mouse Movements</control>
<control lang="en" key="IDT_FAVORITE_ID">Volume ID:</control> <control lang="en" key="IDT_VOLUME_ID">Volume ID:</control>
<string lang="en" key="VOLUME_ID">Volume ID</string>
<control lang="en" key="IDC_FAVORITE_USE_VOLUME_ID">Use Volume ID to mount favorite</control> <control lang="en" key="IDC_FAVORITE_USE_VOLUME_ID">Use Volume ID to mount favorite</control>
<string lang="en" key="VOLUME_ID_INVALID">The Volume ID value is invalid</string> <string lang="en" key="VOLUME_ID_INVALID">The Volume ID value is invalid</string>
<string lang="en" key="VOLUME_ID_NOT_FOUND">No Volume with the specified ID was found on the system</string>
<string lang="en" key="IDPM_COPY_VALUE_TO_CLIPBOARD">Copy Value to Clipboard...</string>
</localization> </localization>
<!-- XML Schema --> <!-- XML Schema -->
<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">

14
src/Driver/Ntdriver.c
View File

@ -1049,7 +1049,7 @@ NTSTATUS ProcessMainDeviceControlIrp (PDEVICE_OBJECT DeviceObject, PEXTENSION Ex
if (opentest->bMatchVolumeID) if (opentest->bMatchVolumeID)
{ {
int volumeType; int volumeType;
BYTE volumeID[SHA512_DIGEST_SIZE]; BYTE volumeID[VOLUME_ID_SIZE];
// Go through all volume types (e.g., normal, hidden) // Go through all volume types (e.g., normal, hidden)
for (volumeType = TC_VOLUME_TYPE_NORMAL; for (volumeType = TC_VOLUME_TYPE_NORMAL;
@ -1069,7 +1069,7 @@ NTSTATUS ProcessMainDeviceControlIrp (PDEVICE_OBJECT DeviceObject, PEXTENSION Ex
break; break;
} }
ntStatus = ZwReadFile (Extension->hDeviceFile, ntStatus = ZwReadFile (NtFileHandle,
NULL, NULL,
NULL, NULL,
NULL, NULL,
@ -1081,10 +1081,10 @@ NTSTATUS ProcessMainDeviceControlIrp (PDEVICE_OBJECT DeviceObject, PEXTENSION Ex
if (NT_SUCCESS (ntStatus)) if (NT_SUCCESS (ntStatus))
{ {
/* compute the ID of this volume: SHA-512 of the effective header */ /* compute the ID of this volume: SHA-256 of the effective header */
sha512 (volumeID, readBuffer, TC_VOLUME_HEADER_EFFECTIVE_SIZE); sha256 (volumeID, readBuffer, TC_VOLUME_HEADER_EFFECTIVE_SIZE);
if (0 == memcmp (volumeID, opentest->volumeID, SHA512_DIGEST_SIZE)) if (0 == memcmp (volumeID, opentest->volumeID, VOLUME_ID_SIZE))
{ {
opentest->VolumeIDMatched = TRUE; opentest->VolumeIDMatched = TRUE;
break; break;
@ -1265,7 +1265,7 @@ NTSTATUS ProcessMainDeviceControlIrp (PDEVICE_OBJECT DeviceObject, PEXTENSION Ex
list->ulMountedDrives |= (1 << ListExtension->nDosDriveNo); list->ulMountedDrives |= (1 << ListExtension->nDosDriveNo);
RtlStringCbCopyW (list->wszVolume[ListExtension->nDosDriveNo], sizeof(list->wszVolume[ListExtension->nDosDriveNo]),ListExtension->wszVolume); RtlStringCbCopyW (list->wszVolume[ListExtension->nDosDriveNo], sizeof(list->wszVolume[ListExtension->nDosDriveNo]),ListExtension->wszVolume);
RtlStringCbCopyW (list->wszLabel[ListExtension->nDosDriveNo], sizeof(list->wszLabel[ListExtension->nDosDriveNo]),ListExtension->wszLabel); RtlStringCbCopyW (list->wszLabel[ListExtension->nDosDriveNo], sizeof(list->wszLabel[ListExtension->nDosDriveNo]),ListExtension->wszLabel);
memcpy (list->volumeID[ListExtension->nDosDriveNo], ListExtension->volumeID, SHA512_DIGEST_SIZE); memcpy (list->volumeID[ListExtension->nDosDriveNo], ListExtension->volumeID, VOLUME_ID_SIZE);
list->diskLength[ListExtension->nDosDriveNo] = ListExtension->DiskLength; list->diskLength[ListExtension->nDosDriveNo] = ListExtension->DiskLength;
list->ea[ListExtension->nDosDriveNo] = ListExtension->cryptoInfo->ea; list->ea[ListExtension->nDosDriveNo] = ListExtension->cryptoInfo->ea;
if (ListExtension->cryptoInfo->hiddenVolume) if (ListExtension->cryptoInfo->hiddenVolume)
@ -1317,7 +1317,7 @@ NTSTATUS ProcessMainDeviceControlIrp (PDEVICE_OBJECT DeviceObject, PEXTENSION Ex
prop->uniqueId = ListExtension->UniqueVolumeId; prop->uniqueId = ListExtension->UniqueVolumeId;
RtlStringCbCopyW (prop->wszVolume, sizeof(prop->wszVolume),ListExtension->wszVolume); RtlStringCbCopyW (prop->wszVolume, sizeof(prop->wszVolume),ListExtension->wszVolume);
RtlStringCbCopyW (prop->wszLabel, sizeof(prop->wszLabel),ListExtension->wszLabel); RtlStringCbCopyW (prop->wszLabel, sizeof(prop->wszLabel),ListExtension->wszLabel);
memcpy (prop->volumeID, ListExtension->volumeID, SHA512_DIGEST_SIZE); memcpy (prop->volumeID, ListExtension->volumeID, VOLUME_ID_SIZE);
prop->bDriverSetLabel = ListExtension->bDriverSetLabel; prop->bDriverSetLabel = ListExtension->bDriverSetLabel;
prop->diskLength = ListExtension->DiskLength; prop->diskLength = ListExtension->DiskLength;
prop->ea = ListExtension->cryptoInfo->ea; prop->ea = ListExtension->cryptoInfo->ea;

2
src/Driver/Ntdriver.h
View File

@ -81,7 +81,7 @@ typedef struct EXTENSION
BOOL bIsNTFS; BOOL bIsNTFS;
BOOL bDriverSetLabel; BOOL bDriverSetLabel;
unsigned char volumeID[SHA512_DIGESTSIZE]; unsigned char volumeID[VOLUME_ID_SIZE];
LARGE_INTEGER fileCreationTime; LARGE_INTEGER fileCreationTime;
LARGE_INTEGER fileLastAccessTime; LARGE_INTEGER fileLastAccessTime;

2
src/Driver/Ntvol.c
View File

@ -518,7 +518,7 @@ NTSTATUS TCOpenVolume (PDEVICE_OBJECT DeviceObject,
Extension->cryptoInfo->bPartitionInInactiveSysEncScope = mount->bPartitionInInactiveSysEncScope; Extension->cryptoInfo->bPartitionInInactiveSysEncScope = mount->bPartitionInInactiveSysEncScope;
/* compute the ID of this volume: SHA-512 of the effective header */ /* compute the ID of this volume: SHA-512 of the effective header */
sha512 (Extension->volumeID, readBuffer, TC_VOLUME_HEADER_EFFECTIVE_SIZE); sha256 (Extension->volumeID, readBuffer, TC_VOLUME_HEADER_EFFECTIVE_SIZE);
if (volumeType == TC_VOLUME_TYPE_NORMAL) if (volumeType == TC_VOLUME_TYPE_NORMAL)
{ {

65
src/Mount/Favorites.cpp
View File

@ -98,7 +98,7 @@ namespace VeraCrypt
favorite.SystemEncryption = prop.partitionInInactiveSysEncScope ? true : false; favorite.SystemEncryption = prop.partitionInInactiveSysEncScope ? true : false;
favorite.OpenExplorerWindow = (bExplore == TRUE); favorite.OpenExplorerWindow = (bExplore == TRUE);
favorite.Pim = prop.volumePim; favorite.Pim = prop.volumePim;
memcpy (favorite.VolumeID, prop.volumeID, SHA512_DIGESTSIZE); memcpy (favorite.VolumeID, prop.volumeID, VOLUME_ID_SIZE);
if (favorite.VolumePathId.empty() if (favorite.VolumePathId.empty()
&& IsVolumeDeviceHosted (favorite.Path.c_str()) && IsVolumeDeviceHosted (favorite.Path.c_str())
@ -421,7 +421,7 @@ namespace VeraCrypt
{ {
HDC hdc = (HDC) wParam; HDC hdc = (HDC) wParam;
HWND hw = (HWND) lParam; HWND hw = (HWND) lParam;
if (hw == GetDlgItem(hwndDlg, IDC_FAVORITE_ID)) if (hw == GetDlgItem(hwndDlg, IDC_FAVORITE_VOLUME_ID))
{ {
// This the favorite ID field. Make its background like normal edit // This the favorite ID field. Make its background like normal edit
HBRUSH hbr = GetSysColorBrush (COLOR_WINDOW); HBRUSH hbr = GetSysColorBrush (COLOR_WINDOW);
@ -582,12 +582,12 @@ namespace VeraCrypt
char label[1024]; char label[1024];
XmlGetAttributeText (xml, "ID", label, sizeof (label)); XmlGetAttributeText (xml, "ID", label, sizeof (label));
if (strlen (label) == 128) if (strlen (label) == (2*VOLUME_ID_SIZE))
{ {
std::vector<byte> arr; std::vector<byte> arr;
if (HexWideStringToArray (Utf8StringToWide (label).c_str(), arr) && arr.size() == SHA512_DIGEST_SIZE) if (HexWideStringToArray (Utf8StringToWide (label).c_str(), arr) && arr.size() == VOLUME_ID_SIZE)
{ {
memcpy (favorite.VolumeID, &arr[0], SHA512_DIGEST_SIZE); memcpy (favorite.VolumeID, &arr[0], VOLUME_ID_SIZE);
} }
} }
@ -639,7 +639,7 @@ namespace VeraCrypt
XmlGetAttributeText (xml, "useVolumeID", boolVal, sizeof (boolVal)); XmlGetAttributeText (xml, "useVolumeID", boolVal, sizeof (boolVal));
if (boolVal[0]) if (boolVal[0])
favorite.UseVolumeID = (boolVal[0] == '1') && !IsRepeatedByteArray (0, favorite.VolumeID, SHA512_DIGEST_SIZE); favorite.UseVolumeID = (boolVal[0] == '1') && !IsRepeatedByteArray (0, favorite.VolumeID, sizeof (favorite.VolumeID));
if (favorite.Path.find (L"\\\\?\\Volume{") == 0 && favorite.Path.rfind (L"}\\") == favorite.Path.size() - 2) if (favorite.Path.find (L"\\\\?\\Volume{") == 0 && favorite.Path.rfind (L"}\\") == favorite.Path.size() - 2)
{ {
@ -738,8 +738,8 @@ namespace VeraCrypt
wstring s = L"\n\t\t<volume mountpoint=\"" + favorite.MountPoint + L"\""; wstring s = L"\n\t\t<volume mountpoint=\"" + favorite.MountPoint + L"\"";
if (!IsRepeatedByteArray (0, favorite.VolumeID, SHA512_DIGEST_SIZE)) if (!IsRepeatedByteArray (0, favorite.VolumeID, sizeof (favorite.VolumeID)))
s += L" ID=\"" + ArrayToHexWideString (favorite.VolumeID, SHA512_DIGEST_SIZE) + L"\""; s += L" ID=\"" + ArrayToHexWideString (favorite.VolumeID, sizeof (favorite.VolumeID)) + L"\"";
if (!favorite.Label.empty()) if (!favorite.Label.empty())
s += L" label=\"" + favorite.Label + L"\""; s += L" label=\"" + favorite.Label + L"\"";
@ -771,7 +771,7 @@ namespace VeraCrypt
if (favorite.UseLabelInExplorer && !favorite.ReadOnly) if (favorite.UseLabelInExplorer && !favorite.ReadOnly)
s += L" useLabelInExplorer=\"1\""; s += L" useLabelInExplorer=\"1\"";
if (favorite.UseVolumeID && !IsRepeatedByteArray (0, favorite.VolumeID, SHA512_DIGEST_SIZE)) if (favorite.UseVolumeID && !IsRepeatedByteArray (0, favorite.VolumeID, sizeof (favorite.VolumeID)))
s += L" useVolumeID=\"1\""; s += L" useVolumeID=\"1\"";
s += L">" + wstring (tq) + L"</volume>"; s += L">" + wstring (tq) + L"</volume>";
@ -840,6 +840,7 @@ namespace VeraCrypt
static void SetControls (HWND hwndDlg, const FavoriteVolume &favorite, bool systemFavoritesMode, bool enable) static void SetControls (HWND hwndDlg, const FavoriteVolume &favorite, bool systemFavoritesMode, bool enable)
{ {
BOOL bIsDevice = IsVolumeDeviceHosted (favorite.Path.c_str()) || !enable;
if (favorite.Pim > 0) if (favorite.Pim > 0)
{ {
wchar_t szTmp[MAX_PIM + 1]; wchar_t szTmp[MAX_PIM + 1];
@ -854,12 +855,14 @@ namespace VeraCrypt
SetCheckBox (hwndDlg, IDC_FAVORITE_MOUNT_ON_ARRIVAL, favorite.MountOnArrival); SetCheckBox (hwndDlg, IDC_FAVORITE_MOUNT_ON_ARRIVAL, favorite.MountOnArrival);
SetCheckBox (hwndDlg, IDC_FAVORITE_MOUNT_READONLY, favorite.ReadOnly); SetCheckBox (hwndDlg, IDC_FAVORITE_MOUNT_READONLY, favorite.ReadOnly);
SetCheckBox (hwndDlg, IDC_FAVORITE_MOUNT_REMOVABLE, favorite.Removable); SetCheckBox (hwndDlg, IDC_FAVORITE_MOUNT_REMOVABLE, favorite.Removable);
SetCheckBox (hwndDlg, IDC_FAVORITE_USE_VOLUME_ID, favorite.UseVolumeID); SetCheckBox (hwndDlg, IDC_FAVORITE_USE_VOLUME_ID, favorite.UseVolumeID && bIsDevice);
if (!IsRepeatedByteArray (0, favorite.VolumeID, SHA512_DIGESTSIZE)) if (IsRepeatedByteArray (0, favorite.VolumeID, sizeof (favorite.VolumeID)) || !bIsDevice)
{ {
SetDlgItemText (hwndDlg, IDC_FAVORITE_ID, ArrayToHexWideString (favorite.VolumeID, SHA512_DIGESTSIZE).c_str()); SetDlgItemText (hwndDlg, IDC_FAVORITE_VOLUME_ID, L"");
} }
else
SetDlgItemText (hwndDlg, IDC_FAVORITE_VOLUME_ID, ArrayToHexWideString (favorite.VolumeID, sizeof (favorite.VolumeID)).c_str());
if (systemFavoritesMode) if (systemFavoritesMode)
{ {
@ -893,6 +896,44 @@ namespace VeraCrypt
EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_MOUNT_REMOVABLE), enable); EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_MOUNT_REMOVABLE), enable);
EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_OPEN_EXPLORER_WIN_ON_MOUNT), enable || systemFavoritesMode); EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_OPEN_EXPLORER_WIN_ON_MOUNT), enable || systemFavoritesMode);
EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_DISABLE_HOTKEY), enable || systemFavoritesMode); EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_DISABLE_HOTKEY), enable || systemFavoritesMode);
EnableWindow (GetDlgItem (hwndDlg, IDT_VOLUME_ID), enable && bIsDevice);
EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_VOLUME_ID), enable && bIsDevice);
EnableWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_USE_VOLUME_ID), enable && bIsDevice && !IsRepeatedByteArray (0, favorite.VolumeID, sizeof (favorite.VolumeID)));
ShowWindow (GetDlgItem (hwndDlg, IDT_VOLUME_ID), bIsDevice? SW_SHOW : SW_HIDE);
ShowWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_VOLUME_ID), bIsDevice? SW_SHOW : SW_HIDE);
ShowWindow (GetDlgItem (hwndDlg, IDC_FAVORITE_USE_VOLUME_ID), bIsDevice? SW_SHOW : SW_HIDE);
// Group box
RECT boxRect, checkRect, labelRect;
GetWindowRect (GetDlgItem (hwndDlg, IDC_FAV_VOL_OPTIONS_GROUP_BOX), &boxRect);
GetWindowRect (GetDlgItem (hwndDlg, IDC_FAVORITE_USE_VOLUME_ID), &checkRect);
GetWindowRect (GetDlgItem (hwndDlg, IDT_VOLUME_ID), &labelRect);
if (!bIsDevice && (boxRect.top < checkRect.top))
{
POINT pt = {boxRect.left, checkRect.bottom};
ScreenToClient (hwndDlg, &pt);
SetWindowPos (GetDlgItem (hwndDlg, IDC_FAV_VOL_OPTIONS_GROUP_BOX), 0, pt.x, pt.y,
boxRect.right - boxRect.left,
boxRect.bottom - checkRect.bottom,
SWP_NOZORDER);
InvalidateRect (GetDlgItem (hwndDlg, IDC_FAV_VOL_OPTIONS_GROUP_BOX), NULL, TRUE);
}
if (bIsDevice && (boxRect.top >= checkRect.top))
{
POINT pt = {boxRect.left, labelRect.top - CompensateYDPI (10)};
ScreenToClient (hwndDlg, &pt);
SetWindowPos (GetDlgItem (hwndDlg, IDC_FAV_VOL_OPTIONS_GROUP_BOX), 0, pt.x, pt.y,
boxRect.right - boxRect.left,
boxRect.bottom - labelRect.top + CompensateYDPI (10),
SWP_NOZORDER);
InvalidateRect (GetDlgItem (hwndDlg, IDC_FAV_VOL_OPTIONS_GROUP_BOX), NULL, TRUE);
}
} }

4
src/Mount/Favorites.h
View File

@ -33,7 +33,7 @@ namespace VeraCrypt
UseLabelInExplorer (false), UseLabelInExplorer (false),
UseVolumeID (false) UseVolumeID (false)
{ {
memset (VolumeID, 0, SHA512_DIGESTSIZE); memset (VolumeID, 0, VOLUME_ID_SIZE);
} }
wstring Path; wstring Path;
@ -41,7 +41,7 @@ namespace VeraCrypt
wstring VolumePathId; wstring VolumePathId;
wstring Label; wstring Label;
int Pim; int Pim;
BYTE VolumeID[SHA512_DIGESTSIZE]; BYTE VolumeID[VOLUME_ID_SIZE];
bool DisableHotkeyMount; bool DisableHotkeyMount;
bool DisconnectedDevice; bool DisconnectedDevice;

229
src/Mount/Mount.c
View File

@ -1900,6 +1900,7 @@ typedef struct
{ {
BOOL bRequireConfirmation; BOOL bRequireConfirmation;
wchar_t *lpszVolume; wchar_t *lpszVolume;
size_t cchVolume;
int* iResult; int* iResult;
} BackupHeaderThreadParam; } BackupHeaderThreadParam;
@ -1907,17 +1908,23 @@ void CALLBACK BackupHeaderWaitThreadProc(void* pArg, HWND hwndDlg)
{ {
BackupHeaderThreadParam* pThreadParam = (BackupHeaderThreadParam*) pArg; BackupHeaderThreadParam* pThreadParam = (BackupHeaderThreadParam*) pArg;
if (TranslateVolumeID (hwndDlg, pThreadParam->lpszVolume, pThreadParam->cchVolume))
{
if (!IsAdmin () && IsUacSupported () && IsVolumeDeviceHosted (pThreadParam->lpszVolume)) if (!IsAdmin () && IsUacSupported () && IsVolumeDeviceHosted (pThreadParam->lpszVolume))
*(pThreadParam->iResult) = UacBackupVolumeHeader (hwndDlg, pThreadParam->bRequireConfirmation, pThreadParam->lpszVolume); *(pThreadParam->iResult) = UacBackupVolumeHeader (hwndDlg, pThreadParam->bRequireConfirmation, pThreadParam->lpszVolume);
else else
*(pThreadParam->iResult) = BackupVolumeHeader (hwndDlg, pThreadParam->bRequireConfirmation, pThreadParam->lpszVolume); *(pThreadParam->iResult) = BackupVolumeHeader (hwndDlg, pThreadParam->bRequireConfirmation, pThreadParam->lpszVolume);
} }
else
*(pThreadParam->iResult) = ERR_OS_ERROR;
}
// implementation for support of restoring header operation in wait dialog mechanism // implementation for support of restoring header operation in wait dialog mechanism
typedef struct typedef struct
{ {
wchar_t *lpszVolume; wchar_t *lpszVolume;
size_t cchVolume;
int* iResult; int* iResult;
} RestoreHeaderThreadParam; } RestoreHeaderThreadParam;
@ -1925,11 +1932,16 @@ void CALLBACK RestoreHeaderWaitThreadProc(void* pArg, HWND hwndDlg)
{ {
RestoreHeaderThreadParam* pThreadParam = (RestoreHeaderThreadParam*) pArg; RestoreHeaderThreadParam* pThreadParam = (RestoreHeaderThreadParam*) pArg;
if (TranslateVolumeID (hwndDlg, pThreadParam->lpszVolume, pThreadParam->cchVolume))
{
if (!IsAdmin () && IsUacSupported () && IsVolumeDeviceHosted (pThreadParam->lpszVolume)) if (!IsAdmin () && IsUacSupported () && IsVolumeDeviceHosted (pThreadParam->lpszVolume))
*(pThreadParam->iResult) = UacRestoreVolumeHeader (hwndDlg, pThreadParam->lpszVolume); *(pThreadParam->iResult) = UacRestoreVolumeHeader (hwndDlg, pThreadParam->lpszVolume);
else else
*(pThreadParam->iResult) = RestoreVolumeHeader (hwndDlg, pThreadParam->lpszVolume); *(pThreadParam->iResult) = RestoreVolumeHeader (hwndDlg, pThreadParam->lpszVolume);
} }
else
*(pThreadParam->iResult) = ERR_OS_ERROR;
}
/* Except in response to the WM_INITDIALOG message, the dialog box procedure /* Except in response to the WM_INITDIALOG message, the dialog box procedure
should return nonzero if it processes the message, and zero if it does should return nonzero if it processes the message, and zero if it does
@ -3584,6 +3596,60 @@ int GetModeOfOperationByDriveNo (int nDosDriveNo)
return 0; return 0;
} }
void DisplayVolumePropertiesListContextMenu (HWND hwndDlg, LPARAM lParam)
{
/* Volume Properties list context menu */
DWORD mPos;
int menuItem;
HWND hList = GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES_LIST);
int hItem = ListView_GetSelectionMark (hList);
SetFocus (hList);
if (hItem >= 0)
{
HMENU popup = CreatePopupMenu ();
AppendMenuW (popup, MF_STRING, IDPM_COPY_VALUE_TO_CLIPBOARD, GetString ("IDPM_COPY_VALUE_TO_CLIPBOARD"));
if (lParam)
{
mPos=GetMessagePos();
}
else
{
POINT pt = {0};
if (ListView_GetItemPosition (hList, hItem, &pt))
{
pt.x += 2 + ::GetSystemMetrics(SM_CXICON);
pt.y += 2;
}
ClientToScreen (hList, &pt);
mPos = MAKELONG (pt.x, pt.y);
}
menuItem = TrackPopupMenu (popup,
TPM_RETURNCMD | TPM_LEFTBUTTON,
GET_X_LPARAM(mPos),
GET_Y_LPARAM(mPos),
0,
hwndDlg,
NULL);
DestroyMenu (popup);
switch (menuItem)
{
case IDPM_COPY_VALUE_TO_CLIPBOARD:
{
wchar_t valueText[256] = {0};
ListView_GetItemText (hList, hItem, 1, valueText, ARRAYSIZE (valueText));
CopyTextToClipboard (valueText);
}
break;
}
}
}
BOOL CALLBACK VolumePropertiesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam) BOOL CALLBACK VolumePropertiesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{ {
@ -3701,6 +3767,16 @@ BOOL CALLBACK VolumePropertiesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LP
else else
ListSubItemSet (list, i++, 1, (wchar_t *) (prop.wszVolume[1] != L'?' ? prop.wszVolume : prop.wszVolume + 4)); ListSubItemSet (list, i++, 1, (wchar_t *) (prop.wszVolume[1] != L'?' ? prop.wszVolume : prop.wszVolume + 4));
if (!bSysEnc && IsVolumeDeviceHosted ((wchar_t *) (prop.wszVolume[1] != L'?' ? prop.wszVolume : prop.wszVolume + 4)))
{
// Volume ID
std::wstring hexID = ArrayToHexWideString (prop.volumeID, sizeof (prop.volumeID));
ListItemAdd (list, i, GetString ("VOLUME_ID"));
ListSubItemSet (list, i++, 1, hexID.c_str());
}
// Size // Size
ListItemAdd (list, i, GetString ("SIZE")); ListItemAdd (list, i, GetString ("SIZE"));
StringCbPrintfW (sw, sizeof(sw), L"%I64u %s", prop.diskLength, GetString ("BYTES")); StringCbPrintfW (sw, sizeof(sw), L"%I64u %s", prop.diskLength, GetString ("BYTES"));
@ -3901,6 +3977,44 @@ BOOL CALLBACK VolumePropertiesDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LP
return 0; return 0;
} }
case WM_NOTIFY:
if(wParam == IDC_VOLUME_PROPERTIES_LIST)
{
/* Right click */
switch (((NM_LISTVIEW *) lParam)->hdr.code)
{
case NM_RCLICK:
case LVN_BEGINRDRAG:
/* If the mouse was moving while the right mouse button is pressed, popup menu would
not open, because drag&drop operation would be initiated. Therefore, we're handling
RMB drag-and-drop operations as well. */
{
DisplayVolumePropertiesListContextMenu (hwndDlg, lParam);
return 1;
}
}
}
return 0;
case WM_CONTEXTMENU:
{
HWND hList = GetDlgItem (hwndDlg, IDC_VOLUME_PROPERTIES_LIST);
// only handle if it is coming from keyboard and if the drive
// list has focus. The other cases are handled elsewhere
if ( (-1 == GET_X_LPARAM(lParam))
&& (-1 == GET_Y_LPARAM(lParam))
&& (GetFocus () == hList)
)
{
DisplayVolumePropertiesListContextMenu (hwndDlg, NULL);
}
}
return 0;
case WM_COMMAND: case WM_COMMAND:
if (lw == IDOK) if (lw == IDOK)
{ {
@ -4442,15 +4556,24 @@ static BOOL Mount (HWND hwndDlg, int nDosDriveNo, wchar_t *szFileName, int pim)
if (szFileName == NULL) if (szFileName == NULL)
{ {
GetVolumePath (hwndDlg, fileName, ARRAYSIZE (fileName)); GetVolumePath (hwndDlg, fileName, ARRAYSIZE (fileName));
szFileName = fileName;
} }
else
StringCchCopyW (fileName, ARRAYSIZE (fileName), szFileName);
if (wcslen(szFileName) == 0) if (wcslen(fileName) == 0)
{ {
status = FALSE; status = FALSE;
goto ret; goto ret;
} }
if (!TranslateVolumeID (hwndDlg, fileName, ARRAYSIZE (fileName)))
{
status = FALSE;
goto ret;
}
szFileName = fileName;
if (IsMountedVolume (szFileName)) if (IsMountedVolume (szFileName))
{ {
Warning ("VOL_ALREADY_MOUNTED", hwndDlg); Warning ("VOL_ALREADY_MOUNTED", hwndDlg);
@ -5129,6 +5252,12 @@ static void ChangePassword (HWND hwndDlg)
int newPimValue = -1; int newPimValue = -1;
GetVolumePath (hwndDlg, szFileName, ARRAYSIZE (szFileName)); GetVolumePath (hwndDlg, szFileName, ARRAYSIZE (szFileName));
if (!TranslateVolumeID (hwndDlg, szFileName, ARRAYSIZE (szFileName)))
{
return;
}
if (IsMountedVolume (szFileName)) if (IsMountedVolume (szFileName))
{ {
Warning (pwdChangeDlgMode == PCDM_CHANGE_PKCS5_PRF ? "MOUNTED_NO_PKCS5_PRF_CHANGE" : "MOUNTED_NOPWCHANGE", hwndDlg); Warning (pwdChangeDlgMode == PCDM_CHANGE_PKCS5_PRF ? "MOUNTED_NO_PKCS5_PRF_CHANGE" : "MOUNTED_NOPWCHANGE", hwndDlg);
@ -6309,7 +6438,11 @@ BOOL CALLBACK MainDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lPa
exitCode = 1; exitCode = 1;
} }
if (szFileName[0] != 0 && !IsMountedVolume (szFileName)) if (szFileName[0] != 0 && !TranslateVolumeID (hwndDlg, szFileName, ARRAYSIZE (szFileName)))
{
exitCode = 1;
}
else if (szFileName[0] != 0 && !IsMountedVolume (szFileName))
{ {
BOOL mounted = FALSE; BOOL mounted = FALSE;
int EffectiveVolumePkcs5 = CmdVolumePkcs5; int EffectiveVolumePkcs5 = CmdVolumePkcs5;
@ -6759,7 +6892,21 @@ BOOL CALLBACK MainDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lPa
foreach (FavoriteVolume favorite, FavoritesOnArrivalMountRequired) foreach (FavoriteVolume favorite, FavoritesOnArrivalMountRequired)
{ {
if (!favorite.VolumePathId.empty()) if (favorite.UseVolumeID)
{
if (IsMountedVolumeID (favorite.VolumeID))
continue;
std::wstring volDevPath = FindDeviceByVolumeID (favorite.VolumeID);
if (volDevPath.length() > 0)
{
favorite.Path = volDevPath;
favorite.DisconnectedDevice = false;
}
else
continue;
}
else if (!favorite.VolumePathId.empty())
{ {
if (IsMountedVolume (favorite.Path.c_str())) if (IsMountedVolume (favorite.Path.c_str()))
continue; continue;
@ -6835,6 +6982,16 @@ BOOL CALLBACK MainDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lPa
continue; continue;
} }
// set DisconnectedDevice field on FavoritesOnArrivalMountRequired element
foreach (FavoriteVolume onArrivalFavorite, FavoritesOnArrivalMountRequired)
{
if (onArrivalFavorite.Path == favorite->Path)
{
onArrivalFavorite.DisconnectedDevice = true;
break;
}
}
favorite = FavoritesMountedOnArrivalStillConnected.erase (favorite); favorite = FavoritesMountedOnArrivalStillConnected.erase (favorite);
deleted = true; deleted = true;
} }
@ -7412,6 +7569,7 @@ BOOL CALLBACK MainDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lPa
BackupHeaderThreadParam threadParam; BackupHeaderThreadParam threadParam;
threadParam.bRequireConfirmation = TRUE; threadParam.bRequireConfirmation = TRUE;
threadParam.lpszVolume = volPath; threadParam.lpszVolume = volPath;
threadParam.cchVolume = ARRAYSIZE (volPath);
threadParam.iResult = &iStatus; threadParam.iResult = &iStatus;
ShowWaitDialog (hwndDlg, TRUE, BackupHeaderWaitThreadProc, &threadParam); ShowWaitDialog (hwndDlg, TRUE, BackupHeaderWaitThreadProc, &threadParam);
@ -7434,6 +7592,7 @@ BOOL CALLBACK MainDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lPa
int iStatus = 0; int iStatus = 0;
RestoreHeaderThreadParam threadParam; RestoreHeaderThreadParam threadParam;
threadParam.lpszVolume = volPath; threadParam.lpszVolume = volPath;
threadParam.cchVolume = ARRAYSIZE (volPath);
threadParam.iResult = &iStatus; threadParam.iResult = &iStatus;
ShowWaitDialog(hwndDlg, TRUE, RestoreHeaderWaitThreadProc, &threadParam); ShowWaitDialog(hwndDlg, TRUE, RestoreHeaderWaitThreadProc, &threadParam);
@ -7717,6 +7876,8 @@ BOOL CALLBACK MainDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lPa
if (VolumeSelected (hwndDlg) if (VolumeSelected (hwndDlg)
&& IsMountedVolume (volPathLower)) && IsMountedVolume (volPathLower))
{ {
TranslateVolumeID (hwndDlg, volPathLower, ARRAYSIZE (volPathLower));
if (LOWORD (selectedDrive) != TC_MLIST_ITEM_NONSYS_VOL) if (LOWORD (selectedDrive) != TC_MLIST_ITEM_NONSYS_VOL)
{ {
driveNo = GetMountedVolumeDriveNo (volPathLower); driveNo = GetMountedVolumeDriveNo (volPathLower);
@ -7852,6 +8013,7 @@ BOOL CALLBACK MainDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lPa
BackupHeaderThreadParam threadParam; BackupHeaderThreadParam threadParam;
threadParam.bRequireConfirmation = TRUE; threadParam.bRequireConfirmation = TRUE;
threadParam.lpszVolume = volPath; threadParam.lpszVolume = volPath;
threadParam.cchVolume = ARRAYSIZE (volPath);
threadParam.iResult = &iStatus; threadParam.iResult = &iStatus;
ShowWaitDialog (hwndDlg, TRUE, BackupHeaderWaitThreadProc, &threadParam); ShowWaitDialog (hwndDlg, TRUE, BackupHeaderWaitThreadProc, &threadParam);
@ -7878,6 +8040,7 @@ BOOL CALLBACK MainDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lPa
int iStatus = 0; int iStatus = 0;
RestoreHeaderThreadParam threadParam; RestoreHeaderThreadParam threadParam;
threadParam.lpszVolume = volPath; threadParam.lpszVolume = volPath;
threadParam.cchVolume = ARRAYSIZE (volPath);
threadParam.iResult = &iStatus; threadParam.iResult = &iStatus;
ShowWaitDialog(hwndDlg, TRUE, RestoreHeaderWaitThreadProc, &threadParam); ShowWaitDialog(hwndDlg, TRUE, RestoreHeaderWaitThreadProc, &threadParam);
@ -8005,9 +8168,16 @@ BOOL CALLBACK MainDialogProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lPa
if (favoriteIndex < FavoriteVolumes.size()) if (favoriteIndex < FavoriteVolumes.size())
{ {
if (IsMountedVolume (FavoriteVolumes[favoriteIndex].Path.c_str())) if ((FavoriteVolumes[favoriteIndex].UseVolumeID && IsMountedVolumeID (FavoriteVolumes[favoriteIndex].VolumeID))
|| (!FavoriteVolumes[favoriteIndex].UseVolumeID && IsMountedVolume (FavoriteVolumes[favoriteIndex].Path.c_str()))
)
{ {
std::wstring volName;
WaitCursor(); WaitCursor();
if (FavoriteVolumes[favoriteIndex].UseVolumeID)
volName = FindDeviceByVolumeID (FavoriteVolumes[favoriteIndex].VolumeID);
else
volName = FavoriteVolumes[favoriteIndex].Path;
OpenVolumeExplorerWindow (GetMountedVolumeDriveNo ((wchar_t*) FavoriteVolumes[favoriteIndex].Path.c_str())); OpenVolumeExplorerWindow (GetMountedVolumeDriveNo ((wchar_t*) FavoriteVolumes[favoriteIndex].Path.c_str()));
NormalCursor(); NormalCursor();
} }
@ -8648,6 +8818,7 @@ static BOOL StartSystemFavoritesService ()
ServiceMode = TRUE; ServiceMode = TRUE;
Silent = TRUE; Silent = TRUE;
DeviceChangeBroadcastDisabled = TRUE; DeviceChangeBroadcastDisabled = TRUE;
bShowDisconnectedNetworkDrives = TRUE;
InitOSVersionInfo(); InitOSVersionInfo();
@ -8920,8 +9091,10 @@ static BOOL MountFavoriteVolumeBase (HWND hwnd, const FavoriteVolume &favorite,
else else
ZeroMemory (mountOptions.Label, sizeof (mountOptions.Label)); ZeroMemory (mountOptions.Label, sizeof (mountOptions.Label));
if (favorite.UseVolumeID && !IsRepeatedByteArray (0, favorite.VolumeID, SHA512_DIGEST_SIZE)) if (favorite.UseVolumeID && !IsRepeatedByteArray (0, favorite.VolumeID, sizeof (favorite.VolumeID)))
effectiveVolumePath = L"ID:" + ArrayToHexWideString (favorite.VolumeID, SHA512_DIGEST_SIZE); {
effectiveVolumePath = FindDeviceByVolumeID (favorite.VolumeID);
}
else else
effectiveVolumePath = favorite.Path; effectiveVolumePath = favorite.Path;
@ -8982,7 +9155,7 @@ static BOOL MountFavoriteVolumeBase (HWND hwnd, const FavoriteVolume &favorite,
BOOL prevReadOnly = mountOptions.ReadOnly; BOOL prevReadOnly = mountOptions.ReadOnly;
if (ServiceMode) if (ServiceMode)
SystemFavoritesServiceLogInfo (wstring (L"Mounting system favorite \"") + favorite.Path + L"\""); SystemFavoritesServiceLogInfo (wstring (L"Mounting system favorite \"") + effectiveVolumePath + L"\"");
status = Mount (hwnd, drive, (wchar_t *) effectiveVolumePath.c_str(), favorite.Pim); status = Mount (hwnd, drive, (wchar_t *) effectiveVolumePath.c_str(), favorite.Pim);
@ -8994,11 +9167,11 @@ static BOOL MountFavoriteVolumeBase (HWND hwnd, const FavoriteVolume &favorite,
if (status) if (status)
{ {
SystemFavoritesServiceLogInfo (wstring (L"Favorite \"") + favorite.Path + wstring (L"\" mounted successfully as ") + (wchar_t) (drive + L'A') + L":"); SystemFavoritesServiceLogInfo (wstring (L"Favorite \"") + effectiveVolumePath + wstring (L"\" mounted successfully as ") + (wchar_t) (drive + L'A') + L":");
} }
else else
{ {
SystemFavoritesServiceLogError (wstring (L"Favorite \"") + favorite.Path + L"\" failed to mount"); SystemFavoritesServiceLogError (wstring (L"Favorite \"") + effectiveVolumePath + L"\" failed to mount");
} }
} }
@ -9039,7 +9212,7 @@ static BOOL MountFavoriteVolumeBase (HWND hwnd, const FavoriteVolume &favorite,
Error ("DRIVE_LETTER_UNAVAILABLE", MainDlg); Error ("DRIVE_LETTER_UNAVAILABLE", MainDlg);
else if (ServiceMode && systemFavorites) else if (ServiceMode && systemFavorites)
{ {
SystemFavoritesServiceLogError (wstring (L"The drive letter ") + (wchar_t) (drive + L'A') + wstring (L" used by favorite \"") + favorite.Path + L"\" is already taken.\nThis system favorite will not be mounted"); SystemFavoritesServiceLogError (wstring (L"The drive letter ") + (wchar_t) (drive + L'A') + wstring (L" used by favorite \"") + effectiveVolumePath + L"\" is already taken.\nThis system favorite will not be mounted");
} }
return status; return status;
@ -9079,6 +9252,26 @@ BOOL MountFavoriteVolumes (HWND hwnd, BOOL systemFavorites, BOOL logOnMount, BOO
wchar_t szTmp[32]; wchar_t szTmp[32];
StringCbPrintf (szTmp, sizeof(szTmp), L"%d", (int) favorites.size()); StringCbPrintf (szTmp, sizeof(szTmp), L"%d", (int) favorites.size());
SystemFavoritesServiceLogInfo (wstring (L"Loaded ") + szTmp + wstring (L" favorites from the file")); SystemFavoritesServiceLogInfo (wstring (L"Loaded ") + szTmp + wstring (L" favorites from the file"));
/* correct set the connected state of the system favorites */
for (vector <FavoriteVolume>::iterator favorite = favorites.begin();
favorite != favorites.end(); favorite++)
{
if (favorite->UseVolumeID)
{
std::wstring path = FindDeviceByVolumeID (favorite->VolumeID);
if (path.empty ())
{
favorite->DisconnectedDevice = true;
}
else
{
favorite->DisconnectedDevice = false;
favorite->Path = path;
favorite->UseVolumeID = false; /* force the use of real path to avoid calling FindDeviceByVolumeID again */
}
}
}
} }
} }
catch (...) catch (...)
@ -9098,6 +9291,9 @@ BOOL MountFavoriteVolumes (HWND hwnd, BOOL systemFavorites, BOOL logOnMount, BOO
if (ServiceMode && systemFavorites && favorite.DisconnectedDevice) if (ServiceMode && systemFavorites && favorite.DisconnectedDevice)
{ {
skippedSystemFavorites.push_back (favorite); skippedSystemFavorites.push_back (favorite);
if (favorite.UseVolumeID)
SystemFavoritesServiceLogWarning (wstring (L"Favorite \"ID:") + ArrayToHexWideString (favorite.VolumeID, sizeof (favorite.VolumeID)) + L"\" is disconnected. It will be ignored.");
else
SystemFavoritesServiceLogWarning (wstring (L"Favorite \"") + favorite.Path + L"\" is disconnected. It will be ignored."); SystemFavoritesServiceLogWarning (wstring (L"Favorite \"") + favorite.Path + L"\" is disconnected. It will be ignored.");
} }
@ -9135,7 +9331,13 @@ BOOL MountFavoriteVolumes (HWND hwnd, BOOL systemFavorites, BOOL logOnMount, BOO
if (favorite->DisconnectedDevice) if (favorite->DisconnectedDevice)
{ {
// check if the favorite is here and get its path // check if the favorite is here and get its path
wstring resolvedPath = VolumeGuidPathToDevicePath (favorite->Path); wstring resolvedPath;
if (favorite->UseVolumeID)
{
resolvedPath = FindDeviceByVolumeID (favorite->VolumeID);
}
else
resolvedPath = VolumeGuidPathToDevicePath (favorite->Path);
if (!resolvedPath.empty()) if (!resolvedPath.empty())
{ {
favorite->DisconnectedDevice = false; favorite->DisconnectedDevice = false;
@ -9145,6 +9347,9 @@ BOOL MountFavoriteVolumes (HWND hwnd, BOOL systemFavorites, BOOL logOnMount, BOO
remainingFavorites--; remainingFavorites--;
// favorite OK. // favorite OK.
if (favorite->UseVolumeID)
SystemFavoritesServiceLogInfo (wstring (L"Favorite \"ID:") + ArrayToHexWideString (favorite->VolumeID, sizeof (favorite->VolumeID)) + L"\" is connected. Performing mount.");
else
SystemFavoritesServiceLogInfo (wstring (L"Favorite \"") + favorite->VolumePathId + L"\" is connected. Performing mount."); SystemFavoritesServiceLogInfo (wstring (L"Favorite \"") + favorite->VolumePathId + L"\" is connected. Performing mount.");
status = MountFavoriteVolumeBase (hwnd, *favorite, lastbExplore, userForcedReadOnly, systemFavorites, logOnMount, hotKeyMount, favoriteVolumeToMount); status = MountFavoriteVolumeBase (hwnd, *favorite, lastbExplore, userForcedReadOnly, systemFavorites, logOnMount, hotKeyMount, favoriteVolumeToMount);

4
src/Mount/Resource.h
View File

@ -176,8 +176,8 @@
#define IDC_PREF_CACHE_PIM 1154 #define IDC_PREF_CACHE_PIM 1154
#define IDC_BOOT_LOADER_CACHE_PIM 1155 #define IDC_BOOT_LOADER_CACHE_PIM 1155
#define IDC_SHOW_DISCONNECTED_NETWORK_DRIVES 1156 #define IDC_SHOW_DISCONNECTED_NETWORK_DRIVES 1156
#define IDT_FAVORITE_ID 1157 #define IDT_VOLUME_ID 1157
#define IDC_FAVORITE_ID 1158 #define IDC_FAVORITE_VOLUME_ID 1158
#define IDC_FAVORITE_USE_VOLUME_ID 1159 #define IDC_FAVORITE_USE_VOLUME_ID 1159
#define IDM_HELP 40001 #define IDM_HELP 40001
#define IDM_ABOUT 40002 #define IDM_ABOUT 40002