////////////////////////////////////////////////////////////////////////////////////
//
// Does the pre-formating of parameters before calling the routine
// that creates the prolog.
//
static PSTR DoWaterMarkProlog(HMODULE hModule, POEMDEV pOemDevmode, PDWORD pdwSize)
{
PSTR pszProlog = NULL;
// Parameters should not be NULL.
if (NULL == hModule ||
NULL == pOemDevmode ||
NULL == pdwSize)
{
ERR(DLLTEXT("CreateWaterMarkProlog: Invalid argument\r\n"));
return NULL;
}
// Only do prolog if Water Mark is enabled.
if(pOemDevmode->bEnabled)
{
CHAR szColor[INITIAL_BUFFER_SIZE] = "\0";
DWORD dwAngleSize = INITIAL_BUFFER_SIZE;
LPSTR pszAngle = NULL;
// Format angle as a string.
do
{
if(NULL != pszAngle)
{
delete[] pszAngle;
dwAngleSize *= 2;
}
pszAngle = new CHAR[dwAngleSize];
} while( (NULL != pszAngle)
&&
(dwAngleSize < 1024)
&&
(FAILED(StringCbPrintfA(pszAngle, dwAngleSize, "%.1f", pOemDevmode->dfRotate)) )
);
if(NULL != pszAngle)
{
// Format text color as string.
if(FAILED(StringCbPrintfA(szColor, sizeof(szColor),
"%1.2f %1.2f %1.2f",
GetPS2RValue(pOemDevmode->crTextColor),
GetPS2GValue(pOemDevmode->crTextColor),
GetPS2BValue(pOemDevmode->crTextColor))))
{
ERR(DLLTEXT("DoWaterMarkProlog() failed to create PostScript color string for water mark."));
}
// Create Water Mark prolog.
pszProlog = CreateWaterMarkProlog(hModule, pdwSize, pOemDevmode->szWaterMark,
pOemDevmode->dwFontSize, szColor, pszAngle);
// Angle string is no longer needed.
delete[] pszAngle;
}
}
return pszProlog;
}
void osi_LogPrint(osi_log_t *logp, FILE_HANDLE handle)
{
char wholemsg[1024], msg[1000];
int i, ix, ioCount;
osi_logEntry_t *lep;
if (!logp->enabled) return;
thrd_EnterCrit(&logp->cs);
for (ix = logp->first, i = 0;
i < logp->nused;
i++, ix++, (ix >= logp->alloc ? ix -= logp->alloc : 0)) {
lep = logp->datap + ix; /* pointer arithmetic */
StringCbPrintfA(msg, sizeof(msg), lep->formatp,
lep->parms[0], lep->parms[1],
lep->parms[2], lep->parms[3],
lep->parms[4]);
StringCbPrintfA(wholemsg, sizeof(wholemsg),
"time %d.%06d, tid %d %s\r\n",
lep->micros / 1000000,
lep->micros % 1000000,
lep->tid, msg);
if (!WriteFile(handle, wholemsg, strlen(wholemsg),
&ioCount, NULL))
break;
}
thrd_LeaveCrit(&logp->cs);
}
/* add an element to a log */
void osi_LogAdd(osi_log_t *logp, char *formatp, size_t p0, size_t p1, size_t p2, size_t p3, size_t p4)
{
osi_logEntry_t *lep;
long ix;
LARGE_INTEGER bigTime;
/* handle init races */
if (!logp) return;
/* do this w/o locking for speed; it is obviously harmless if we're off
* by a bit.
*/
if (!logp->enabled) return;
thrd_EnterCrit(&logp->cs);
if (logp->nused < logp->alloc) logp->nused++;
else {
logp->first++;
if (logp->first >= logp->alloc) logp->first -= logp->alloc;
}
ix = logp->first + logp->nused - 1;
if (ix >= logp->alloc) ix -= logp->alloc;
lep = logp->datap + ix; /* ptr arith */
lep->tid = thrd_Current();
/* get the time, using the high res timer if available */
if (osi_logFreq) {
QueryPerformanceCounter(&bigTime);
lep->micros = (bigTime.LowPart / osi_logFreq) * osi_logTixToMicros;
}
else lep->micros = GetCurrentTime() * 1000;
lep->formatp = formatp;
lep->parms[0] = p0;
lep->parms[1] = p1;
lep->parms[2] = p2;
lep->parms[3] = p3;
lep->parms[4] = p4;
#ifdef NOTSERVICE
printf( "%9ld:", lep->micros );
printf( formatp, p0, p1, p2, p3, p4);
printf( "\n" );
#endif
if(ISCLIENTDEBUGLOG(osi_TraceOption)) {
char wholemsg[1024], msg[1000];
StringCbPrintfA(msg, sizeof(msg), formatp,
p0, p1, p2, p3, p4);
StringCbPrintfA(wholemsg, sizeof(wholemsg),
"tid[%d] %s\n",
lep->tid, msg);
OutputDebugStringA(wholemsg);
}
thrd_LeaveCrit(&logp->cs);
}
int CLDEditTxtFile::_LoadTxtFileWithItems(CSimpleArray<CString>& arrFileItems)
{
int nRet = -1;
USES_CONVERSION;
char pszFilePath[MAX_PATH] = {0};
StringCbPrintfA(pszFilePath, sizeof(pszFilePath), "%s", W2A(m_strTxtFile));
FILE* pFile = NULL;
//open file
fopen_s(&pFile, const_cast<char*>(pszFilePath), "r");
if (NULL == pFile)
return nRet;
char pszFileValue[1024] = {0};
ZeroMemory(pszFileValue, sizeof(pszFileValue));
arrFileItems.RemoveAll();
while(NULL != fgets(pszFileValue, sizeof(pszFileValue), pFile))
{
if (NULL != m_pStop && TRUE == *m_pStop)
return nRet;
arrFileItems.Add(CString(pszFileValue));
ZeroMemory(pszFileValue, sizeof(pszFileValue));
}
if (NULL != pFile)
fclose(pFile);
pFile = NULL;
nRet = arrFileItems.GetSize();
return nRet;
}
filePathLinkA(const string& path) :m_ntType("\\??\\")
{
if (path.length() > 4 && path.substr(0, 4) == "\\??\\")
{
m_ntType.append(path.substr(4));
}
else
{
m_ntType.append(path);
}
static DWORD tick = 0;
char tmpBuffer[100];
StringCbPrintfA(tmpBuffer, 100, "%x%x%x%x", GetCurrentThreadId(), GetTickCount(), rand(), ++tick);
m_pathDefine = string(FS_BYPASS_DEFINE_PREFIX_A) + tmpBuffer;
if (DefineDosDeviceA(DDD_RAW_TARGET_PATH, m_pathDefine.c_str(), m_ntType.c_str()))
{
m_pathLink = string("\\\\.\\") + FS_BYPASS_DEFINE_PREFIX_A + tmpBuffer;
m_transformed = true;
}
else
{
m_pathLink = path;
m_transformed = false;
}
}
char *osi_LogSaveString(osi_log_t *logp, char *s)
{
char *saveplace;
if (!logp) return s;
if (!logp->enabled) return s;
if (s == NULL) return NULL;
thrd_EnterCrit(&logp->cs);
saveplace = logp->stringsp[logp->stringindex];
if (strlen(s) >= OSI_LOG_STRINGSIZE)
StringCbPrintfA(saveplace, OSI_LOG_STRINGSIZE,
"...%s",
s + strlen(s) - (OSI_LOG_STRINGSIZE - 4));
else
StringCbCopyA(saveplace, OSI_LOG_STRINGSIZE, s);
logp->stringindex++;
if (logp->stringindex >= logp->maxstringindex)
logp->stringindex = 0;
thrd_LeaveCrit(&logp->cs);
return saveplace;
}
void send_msg(const char *type, const char *msg)
{
DWORD written = 0;
char buf[512];
StringCbPrintfA(buf, sizeof(buf), "%s:%s", type, msg);
WriteFile(hClientPipe, buf, strlen(buf)+1, &written, NULL);
}
std::ostream &operator << (std::ostream &str,const LogTime &log_time){
char timebuf[40]={};
const SYSTEMTIME &tm=log_time.m_Time;
long tmp=clock();
StringCbPrintfA(timebuf,sizeof(timebuf),"%02d %02d:%02d:%02d.%03d %6lu",
tm.wDay,tm.wHour,tm.wMinute,tm.wSecond,tm.wMilliseconds,tmp-time_count);
time_count = tmp;
return str << timebuf;
}
int CLDEditTxtFile::WriteItemsToFile(CString strFile, CSimpleArray<CString> arrItems)
{
int nRet = -1;
USES_CONVERSION;
CBkProcPrivilege privilege;
if (!privilege.EnableShutdown())
return -1;
char pszFilePath[MAX_PATH] = {0};
CString strDesFile = strFile;
StringCbPrintfA(pszFilePath, sizeof(pszFilePath), "%s_tmp", W2A(strFile));
DWORD dwFileAttr = ::GetFileAttributes(strFile);
// dwFileAttr &= ~FILE_ATTRIBUTE_READONLY;
::SetFileAttributes(strFile, FILE_ATTRIBUTE_NORMAL);
FILE* pFile = NULL;
//open file
fopen_s(&pFile, const_cast<char*>(pszFilePath), "w+b");
if (NULL == pFile)
{
::SetFileAttributes(strFile, dwFileAttr);
return nRet;
}
//write file
int nCount = arrItems.GetSize();
for (int i = 0; i < nCount; i++)
{
if (NULL != m_pStop && TRUE == *m_pStop)
break;
CString strValue = arrItems[i];
if (TRUE == strValue.IsEmpty())
continue;
fputs(CW2A(strValue.GetBuffer(-1)), pFile);
if (strValue.Right(1) != "\n")
fputs("\r\n", pFile);
strValue.ReleaseBuffer(-1);
}
if (NULL != pFile)
fclose(pFile);
pFile = NULL;
MoveFileEx(CString(pszFilePath), strDesFile, MOVEFILE_REPLACE_EXISTING);
::SetFileAttributes(strDesFile, dwFileAttr);
nRet = 0;
return nRet;
}
struct VFile* _vdwOpenFile(struct VDir* vd, const char* path, int mode) {
struct VDirW32* vdw = (struct VDirW32*) vd;
if (!path) {
return 0;
}
const char* dir = vdw->path;
size_t size = sizeof(char) * (strlen(path) + strlen(dir) + 2);
char* combined = malloc(size);
StringCbPrintfA(combined, size, "%s\\%s", dir, path);
struct VFile* file = VFileOpen(combined, mode);
free(combined);
return file;
}
long osi_LogFDGetInfo(osi_fd_t *ifd, osi_remGetInfoParms_t *outp)
{
osi_logFD_t *lfdp;
osi_log_t *logp;
osi_logEntry_t *lep;
char tbuffer[256];
long ix;
lfdp = (osi_logFD_t *) ifd;
logp = lfdp->logp;
/* see if we're done */
if (lfdp->current >= lfdp->nused) return OSI_DBRPC_EOF;
/* grab lock */
thrd_EnterCrit(&logp->cs);
/* compute which one we want */
ix = lfdp->first + lfdp->current;
if (ix >= logp->alloc) ix -= logp->alloc;
lfdp->current++;
lep = logp->datap + ix; /* ptr arith to current index */
StringCbPrintfA(tbuffer, sizeof(tbuffer), lep->formatp, lep->parms[0], lep->parms[1],
lep->parms[2], lep->parms[3], lep->parms[4]);
/* now copy out info */
StringCbCopyA(outp->sdata[0], sizeof(outp->sdata[0]), tbuffer);
StringCbPrintfA(tbuffer, sizeof(tbuffer), "%5.6f", ((double)lep->micros)/1000000.0);
StringCbCopyA(outp->sdata[1], sizeof(outp->sdata[0]), tbuffer);
outp->idata[0] = lep->tid;
outp->scount = 2;
outp->icount = 1;
thrd_LeaveCrit(&logp->cs);
return 0;
}
static void dump(const char *name, const void *ptr, size_t siz)
{
char buf[256], sz[16];
StringCbCopyA(buf, sizeof(buf), name);
StringCbCatA(buf, sizeof(buf), ": ");
const BYTE *pb = reinterpret_cast<const BYTE *>(ptr);
while (siz--)
{
StringCbPrintfA(sz, sizeof(sz), "%02X ", *pb++);
StringCbCatA(buf, sizeof(buf), sz);
}
trace("%s\n", buf);
}
void SetCurrentVolSize(HWND hwndDlg, uint64 size)
{
const uint64 Muliplier[] = {BYTES_PER_KB, BYTES_PER_MB, BYTES_PER_GB, BYTES_PER_TB};
const int IdRadioBtn[] = {IDC_KB, IDC_MB, IDC_GB, IDC_TB};
const int nMaxSuffix = sizeof(Muliplier)/sizeof(uint64) - 1;
int i;
char szTemp[256];
for (i=1; i<=nMaxSuffix && size>Muliplier[i]; i++) ;
--i;
SendDlgItemMessage (hwndDlg, IdRadioBtn[i], BM_SETCHECK, BST_CHECKED, 0);
StringCbPrintfA(szTemp,sizeof(szTemp),"%I64u",size/Muliplier[i]);
SetWindowText (GetDlgItem (hwndDlg, IDC_SIZEBOX), szTemp);
}
struct VDir* _vdwOpenDir(struct VDir* vd, const char* path) {
struct VDirW32* vdw = (struct VDirW32*) vd;
if (!path) {
return 0;
}
const char* dir = vdw->path;
size_t size = sizeof(char) * (strlen(path) + strlen(dir) + 2);
char* combined = malloc(size);
StringCbPrintfA(combined, size, "%s\\%s", dir, path);
struct VDir* vd2 = VDirOpen(combined);
if (!vd2) {
vd2 = VDirOpenArchive(combined);
}
free(combined);
return vd2;
}
/// @brief
std::string variant_to_str(const VARIANT& var)
{
char buf[128] = { 0 };
switch (var.vt)
{
case VT_NULL:
case VT_EMPTY:
return "NULL";
case VT_I2:
StringCbPrintfA(buf, sizeof(buf), "0x%x", (int16_t)var.iVal);
return std::string(buf);
case VT_I4:
StringCbPrintfA(buf, sizeof(buf), "0x%x", (int32_t)var.lVal);
return std::string(buf);
case VT_UI1:
StringCbPrintfA(buf, sizeof(buf), "0x%x", (uint8_t)var.cVal);
return std::string(buf);
case VT_UI2:
StringCbPrintfA(buf, sizeof(buf), "0x%x", (uint16_t)var.uiVal);
return std::string(buf);
case VT_UI4:
StringCbPrintfA(buf, sizeof(buf), "0x%x", (uint32_t)var.ulVal);
return std::string(buf);
case VT_INT:
StringCbPrintfA(buf, sizeof(buf), "0x%x", (int32_t)var.intVal);
return std::string(buf);
case VT_UINT:
StringCbPrintfA(buf, sizeof(buf), "0x%x", (uint32_t)var.uintVal);
return std::string(buf);
case VT_BSTR:
return std::string(WcsToMbsEx(var.bstrVal));
default:
StringCbPrintfA(buf, sizeof(buf), "unknwon type (vt=0x%x)", var.vt);
return std::string(buf);
};
#pragma todo("complete this function...")
}
bool CPlaylist::Save()
{
DWORD dwToWrite, dwWritten;
DWORD dwASXDataLen = 0;
DWORD dwFileAttrib;
char * pszASXData = NULL;
playlist_t * pTrack;
char szFilename[MAX_PATH];
HANDLE hFile;
BOOL bWrite;
bool bResult = true;
// Don't save a playlist that wasn't created by the player
if (false == m_bCEPlaylist || true == m_bTransient)
{
return true;
}
if (m_bHidden)
{
dwFileAttrib = FILE_ATTRIBUTE_HIDDEN;
}
else
{
dwFileAttrib = FILE_ATTRIBUTE_NORMAL;
}
hFile = CreateFile(m_pszPath, GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, dwFileAttrib, NULL);
if (INVALID_HANDLE_VALUE != hFile)
{
bWrite = FALSE;
// write out the header
dwASXDataLen = sizeof (c_szASXHeaderFormat) + 10;
if (pszASXData = new char[dwASXDataLen])
{
pszASXData[0] = '\0';
if(SUCCEEDED(StringCbPrintfA(pszASXData, dwASXDataLen, c_szASXHeaderFormat, m_iCurrentTrack)))
{
if(SUCCEEDED(StringCbLengthA(pszASXData, dwASXDataLen, (size_t*)&dwToWrite)))
{
dwWritten = 0;
bWrite = WriteFile(hFile, pszASXData, dwToWrite, &dwWritten, NULL);
}
else
{
bWrite = FALSE;
}
}
else
{
bWrite = FALSE;
}
}
if (FALSE == bWrite || dwToWrite != dwWritten)
{
bResult = false;
}
}
else
{
bResult = false;
}
pTrack = m_pList;
while (NULL != pTrack && bResult)
{
LPCTSTR pszPath = pTrack->pClip->GetPath();
szFilename[0] = '\0';
if (NETWORK != pTrack->pClip->GetLocation())
{
#ifdef _UNICODE
_snprintf(szFilename, MAX_PATH-1, "file://%ls", pszPath);
#else
_snprintf(szFilename, MAX_PATH-1, "file://%s", pszPath);
#endif /* _UNICODE */
szFilename[MAX_PATH-1] = '\0';
}
else
{
#ifdef _UNICODE
WideCharToMultiByte(CP_ACP, 0, pszPath, -1, szFilename, MAX_PATH, NULL, NULL);
#else
strncpy(szFilename, pszPath, MAX_PATH);
pszPath[MAX_PATH-1] = '\0';
#endif /* _UNICODE */
}
dwToWrite = sizeof (c_szASXEntryFormat) + strlen(szFilename);
if (dwASXDataLen < dwToWrite)
{
delete [] pszASXData;
pszASXData = new char [dwToWrite];
dwASXDataLen = dwToWrite;
}
if((NULL != pszASXData) && (SUCCEEDED(StringCbPrintfA(pszASXData, dwToWrite, c_szASXEntryFormat, szFilename))))
{
if(SUCCEEDED(StringCbLengthA(pszASXData, dwASXDataLen, (size_t*)&dwToWrite)))
{
dwWritten = 0;
bWrite = WriteFile(hFile, pszASXData, dwToWrite, &dwWritten, NULL);
}
else
{
bWrite = FALSE;
}
}
else
{
bWrite = FALSE;
}
if (FALSE == bWrite || dwToWrite != dwWritten)
{
bResult = false;
}
pTrack = pTrack->pNext;
}
if (INVALID_HANDLE_VALUE != hFile && NULL != pszASXData)
{
// write out the footer
size_t ASXFooterFormatLen = sizeof (c_szASXFooterFormat);
if (dwASXDataLen < ASXFooterFormatLen)
{
delete [] pszASXData;
pszASXData = new char [ASXFooterFormatLen];
}
if((NULL != pszASXData) && (SUCCEEDED(StringCbCopyA(pszASXData, ASXFooterFormatLen, c_szASXFooterFormat))))
{
if(SUCCEEDED(StringCbLengthA(pszASXData, ASXFooterFormatLen, (size_t*)&dwToWrite)))
{
dwWritten = 0;
bWrite = WriteFile(hFile, pszASXData, dwToWrite, &dwWritten, NULL);
}
else
{
bWrite = FALSE;
}
}
else
{
bWrite = FALSE;
}
if (FALSE == bWrite || dwToWrite != dwWritten)
{
bResult = false;
}
CloseHandle(hFile);
}
else if (INVALID_HANDLE_VALUE != hFile)
{
CloseHandle(hFile);
}
delete [] pszASXData;
return bResult;
}
BOOL CALLBACK ExpandVolSizeDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
static EXPAND_VOL_THREAD_PARAMS *pVolExpandParam;
WORD lw = LOWORD (wParam);
switch (msg)
{
case WM_INITDIALOG:
{
char szTemp[4096];
pVolExpandParam = (EXPAND_VOL_THREAD_PARAMS*)lParam;
EnableWindow (GetDlgItem (hwndDlg, IDC_SIZEBOX), !pVolExpandParam->bIsDevice);
EnableWindow (GetDlgItem (hwndDlg, IDC_KB), !pVolExpandParam->bIsDevice);
EnableWindow (GetDlgItem (hwndDlg, IDC_MB), !pVolExpandParam->bIsDevice);
EnableWindow (GetDlgItem (hwndDlg, IDC_GB), !pVolExpandParam->bIsDevice);
EnableWindow (GetDlgItem (hwndDlg, IDC_TB), !pVolExpandParam->bIsDevice);
EnableWindow (GetDlgItem (hwndDlg, IDC_INIT_NEWSPACE),
!(pVolExpandParam->bIsLegacy && pVolExpandParam->bIsDevice));
SendDlgItemMessage (hwndDlg, IDC_INIT_NEWSPACE, BM_SETCHECK,
pVolExpandParam->bInitFreeSpace ? BST_CHECKED : BST_UNCHECKED, 0);
if (!pVolExpandParam->bIsDevice)
SetCurrentVolSize(hwndDlg,pVolExpandParam->oldSize);
SendMessage (GetDlgItem (hwndDlg, IDC_BOX_HELP), WM_SETFONT, (WPARAM) hBoldFont, (LPARAM) TRUE);
GetSpaceString(szTemp,sizeof(szTemp),pVolExpandParam->oldSize,pVolExpandParam->bIsDevice);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_OLDSIZE), szTemp);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_NAME), pVolExpandParam->szVolumeName);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_FILE_SYSTEM), szFileSystemStr[pVolExpandParam->FileSystem]);
if (pVolExpandParam->bIsDevice)
{
GetSpaceString(szTemp,sizeof(szTemp),pVolExpandParam->newSize,TRUE);
}
else
{
char szHostFreeStr[256];
SetWindowText (GetDlgItem (hwndDlg, IDT_NEW_SIZE), "");
GetSpaceString(szHostFreeStr,sizeof(szHostFreeStr),pVolExpandParam->hostSizeFree,FALSE);
StringCbPrintfA (szTemp,sizeof(szTemp),"%s available on host drive", szHostFreeStr);
}
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_NEWSIZE), szTemp);
// set help text
if (pVolExpandParam->bIsDevice)
{
StringCbPrintfA (szTemp,sizeof(szTemp),"This is a device-based VeraCrypt volume.\n\nThe new volume size will be choosen automatically as the size of the host device.");
if (pVolExpandParam->bIsLegacy)
StringCbCatA(szTemp,sizeof(szTemp)," Note: filling the new space with random data is not supported for legacy volumes.");
}
else
{
StringCbPrintfA (szTemp, sizeof(szTemp),"Please specify the new size of the VeraCrypt volume (must be at least %I64u KB larger than the current size).",TC_MINVAL_FS_EXPAND/1024);
}
SetWindowText (GetDlgItem (hwndDlg, IDC_BOX_HELP), szTemp);
}
return 0;
case WM_COMMAND:
if (lw == IDCANCEL)
{
EndDialog (hwndDlg, lw);
return 1;
}
if (lw == IDOK)
{
char szTemp[4096];
pVolExpandParam->bInitFreeSpace = IsButtonChecked (GetDlgItem (hwndDlg, IDC_INIT_NEWSPACE));
if (!pVolExpandParam->bIsDevice) // for devices new size is set by calling function
{
GetWindowText (GetDlgItem (hwndDlg, IDC_SIZEBOX), szTemp, sizeof (szTemp));
pVolExpandParam->newSize = _atoi64(szTemp) * GetSizeBoxMultiplier(hwndDlg);
}
EndDialog (hwndDlg, lw);
return 1;
}
return 0;
}
return 0;
}
BOOL CALLBACK ExpandVolProgressDlgProc (HWND hwndDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
static EXPAND_VOL_THREAD_PARAMS *pProgressDlgParam;
static BOOL bVolTransformStarted = FALSE;
static BOOL showRandPool = TRUE;
WORD lw = LOWORD (wParam);
switch (msg)
{
case WM_INITDIALOG:
{
char szOldHostSize[512], szNewHostSize[512];
pProgressDlgParam = (EXPAND_VOL_THREAD_PARAMS*)lParam;
bVolTransformStarted = FALSE;
showRandPool = TRUE;
hCurPage = hwndDlg;
nPbar = IDC_PROGRESS_BAR;
GetSpaceString(szOldHostSize,sizeof(szOldHostSize),pProgressDlgParam->oldSize,pProgressDlgParam->bIsDevice);
GetSpaceString(szNewHostSize,sizeof(szNewHostSize),pProgressDlgParam->newSize,pProgressDlgParam->bIsDevice);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_OLDSIZE), szOldHostSize);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_NEWSIZE), szNewHostSize);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_NAME), pProgressDlgParam->szVolumeName);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_FILE_SYSTEM), szFileSystemStr[pProgressDlgParam->FileSystem]);
SetWindowText (GetDlgItem (hwndDlg, IDC_EXPAND_VOLUME_INITSPACE), pProgressDlgParam->bInitFreeSpace?"Yes":"No");
SendMessage (GetDlgItem (hwndDlg, IDC_BOX_STATUS), WM_SETFONT, (WPARAM) hBoldFont, (LPARAM) TRUE);
SendMessage (GetDlgItem (hwndDlg, IDC_RANDOM_BYTES), WM_SETFONT, (WPARAM) hFixedDigitFont, (LPARAM) TRUE);
// set status text
if ( !pProgressDlgParam->bInitFreeSpace && pProgressDlgParam->bIsLegacy )
{
showRandPool = FALSE;
EnableWindow (GetDlgItem (hwndDlg, IDC_DISPLAY_POOL_CONTENTS), FALSE);
EnableWindow (GetDlgItem (hwndDlg, IDC_RANDOM_BYTES), FALSE);
SetDlgItemText(hwndDlg, IDC_BOX_STATUS, "Click 'Continue' to expand the volume.");
}
else
{
SetDlgItemText(hwndDlg, IDC_BOX_STATUS, "IMPORTANT: Move your mouse as randomly as possible within this window. The longer you move it, the better. This significantly increases the cryptographic strength of the encryption keys. Then click 'Continue' to expand the volume.");
}
SendMessage (GetDlgItem (hwndDlg, IDC_DISPLAY_POOL_CONTENTS), BM_SETCHECK, showRandPool ? BST_CHECKED : BST_UNCHECKED, 0);
SetTimer (hwndDlg, TIMER_ID_RANDVIEW, TIMER_INTERVAL_RANDVIEW, NULL);
}
return 0;
case TC_APPMSG_VOL_TRANSFORM_THREAD_ENDED:
{
int nStatus = (int)lParam;
NormalCursor ();
if (nStatus != 0)
{
if ( nStatus != ERR_USER_ABORT )
AddProgressDlgStatus (hwndDlg, "Error: volume expansion failed.");
else
AddProgressDlgStatus (hwndDlg, "Error: operation aborted by user.");
}
else
{
AddProgressDlgStatus (hwndDlg, "Finished. Volume successfully expanded.");
}
SetWindowText (GetDlgItem (hwndDlg, IDOK), "Exit");
EnableWindow (GetDlgItem (hwndDlg, IDOK), TRUE);
EnableWindow (GetDlgItem (hwndDlg, IDCANCEL), FALSE);
}
return 1;
case WM_TIMER:
switch (wParam)
{
case TIMER_ID_RANDVIEW:
{
unsigned char tmp[16] = {0};
char szRndPool[64] = {0};
if (!showRandPool)
return 1;
RandpeekBytes (hwndDlg, tmp, sizeof (tmp));
StringCbPrintfA (szRndPool, sizeof(szRndPool), "%08X%08X%08X%08X",
*((DWORD*) (tmp + 12)), *((DWORD*) (tmp + 8)), *((DWORD*) (tmp + 4)), *((DWORD*) (tmp)));
SetWindowText (GetDlgItem (hwndDlg, IDC_RANDOM_BYTES), szRndPool);
burn (tmp, sizeof(tmp));
burn (szRndPool, sizeof(szRndPool));
}
return 1;
}
return 0;
case WM_COMMAND:
if (lw == IDC_DISPLAY_POOL_CONTENTS)
{
showRandPool = IsButtonChecked (GetDlgItem (hwndDlg, IDC_DISPLAY_POOL_CONTENTS));
return 1;
}
if (lw == IDCANCEL)
{
if (bVolTransformStarted)
{
if (MessageBoxW (hwndDlg, L"Warning: Volume expansion is in progress!\n\nStopping now may result in a damaged volume.\n\nDo you really want to cancel?", lpszTitle, YES_NO|MB_ICONQUESTION|MB_DEFBUTTON2) == IDNO)
return 1;
// tell the volume transform thread to terminate
bVolTransformThreadCancel = TRUE;
}
EndDialog (hwndDlg, lw);
return 1;
}
if (lw == IDOK)
{
if (bVolTransformStarted)
{
// TransformThreadFunction finished -> OK button is now exit
EndDialog (hwndDlg, lw);
}
else
{
showRandPool = FALSE;
KillTimer (hwndDlg, TIMER_ID_RANDVIEW);
EnableWindow (GetDlgItem (hwndDlg, IDC_DISPLAY_POOL_CONTENTS), FALSE);
EnableWindow (GetDlgItem (hwndDlg, IDOK), FALSE);
SetProgressDlgStatus (hwndDlg, "Starting volume expansion ...\r\n");
bVolTransformStarted = TRUE;
pProgressDlgParam->hwndDlg = hwndDlg;
if ( _beginthread (volTransformThreadFunction, 0, pProgressDlgParam) == -1L )
{
handleError (hwndDlg, ERR_OS_ERROR, SRC_POS);
EndDialog (hwndDlg, lw);
}
WaitCursor();
}
return 1;
}
return 0;
}
return 0;
}
bool create_bob_txt()
{
// current directory 를 구한다.
wchar_t *buf=NULL;
uint32_t buflen = 0;
buflen = GetCurrentDirectoryW(buflen, buf);
if (0 == buflen)
{
print("err, GetCurrentDirectoryW() failed. gle = 0x%08x", GetLastError());
return false;
}
buf = (PWSTR) malloc(sizeof(WCHAR) * buflen);
if (0 == GetCurrentDirectoryW(buflen, buf))
{
print("err, GetCurrentDirectoryW() failed. gle = 0x%08x", GetLastError());
free(buf);
return false;
}
// current dir \\ bob.txt 파일명 생성
wchar_t file_name[260];
if (!SUCCEEDED(StringCbPrintfW(
file_name,
sizeof(file_name),
L"%ws\\bob.txt",
buf)))
{
print("err, can not create file name");
free(buf);
return false;
}
if (true == is_file_existsW(file_name))
{
::DeleteFileW(file_name);
}
// 파일 생성
HANDLE file_handle = CreateFileW(
file_name,
GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
CREATE_NEW,
FILE_ATTRIBUTE_NORMAL,
NULL);
if(file_handle == INVALID_HANDLE_VALUE)
{
print("err, CreateFile(path=%ws), gle=0x%08x", file_name, GetLastError());
return false;
}
// 파일에 데이터 쓰기
DWORD bytes_written = 0;
wchar_t string_buf[1024];
if (!SUCCEEDED(StringCbPrintfW(
string_buf,
sizeof(string_buf),
L"동해물과 백두산이 마르고 닳도록 하느님이 보우하사 우리나라만세")))
{
print("err, can not create data to write.");
CloseHandle(file_handle);
return false;
}
char *pUtf8 =NULL;
int len = UnicodeToUtf8(string_buf,&pUtf8);
if (!WriteFile(file_handle, pUtf8, len, &bytes_written, NULL))
{
print("err, WriteFile() failed. gle = 0x%08x", GetLastError());
CloseHandle(file_handle);
return false;
}
// 영어로 쓰기
if (!SUCCEEDED(StringCbPrintfW(
string_buf,
sizeof(string_buf),
L"All work and no play makes jack a dull boy.")))
{
print("err, can not create data to write.");
CloseHandle(file_handle);
return false;
}
free(pUtf8);
*pUtf8 =NULL;
len = UnicodeToUtf8(string_buf,&pUtf8);
if (!WriteFile(file_handle, string_buf, wcslen(string_buf), &bytes_written, NULL))
{
print("err, WriteFile() failed. gle = 0x%08x", GetLastError());
CloseHandle(file_handle);
return false;
}
char string_bufa[1024];
if (!SUCCEEDED(StringCbPrintfA(
string_bufa,
sizeof(string_bufa),
"동해물과 백두산이 마르고 닳도록 하느님이 보우하사 우리나라만세")))
{
print("err, can not create data to write.");
CloseHandle(file_handle);
return false;
}
free(pUtf8);
pUtf8 =NULL;
pUtf8 =ANSIToUTF8(string_bufa);
len = strlen(pUtf8);
if (!WriteFile(file_handle, pUtf8, len, &bytes_written, NULL))
{
print("err, WriteFile() failed. gle = 0x%08x", GetLastError());
CloseHandle(file_handle);
return false;
}
// 영어로 쓰기
if (!SUCCEEDED(StringCbPrintfA(
string_bufa,
sizeof(string_bufa),
"All work and no play makes jack a dull boy.")))
{
print("err, can not create data to write.");
CloseHandle(file_handle);
return false;
}
free(pUtf8);
pUtf8 =NULL;
pUtf8 =ANSIToUTF8(string_bufa);
len = strlen(pUtf8);
if (!WriteFile(file_handle, string_bufa, strlen(string_bufa), &bytes_written, NULL))
{
print("err, WriteFile() failed. gle = 0x%08x", GetLastError());
CloseHandle(file_handle);
return false;
}
free(pUtf8);
// 파일 닫기
CloseHandle(file_handle);
wchar_t copy_file_name[260];
if (!SUCCEEDED(StringCbPrintfW(
copy_file_name,
sizeof(copy_file_name),
L"%ws\\bob2.txt",
buf)))
{
print("err, can not copy file name");
free(buf);
return false;
}
free(buf); buf = NULL;
/* BOB.txt -> BOB2.txt 파일 복사 */
if(!CopyFileW(file_name,copy_file_name,false)){
print("CopyFileW fail");
return false;
}
/* ReadFile()을 통한 읽기 후 출력*/
HANDLE read_file_handle = CreateFileW(
copy_file_name,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
0,
NULL);
if(read_file_handle == INVALID_HANDLE_VALUE)
{
print("err, CreateFile(path=%ws), gle=0x%08x", read_file_handle, GetLastError());
return false;
}
char read_buf[512];
char buf_noNull[512];
char* ansi_buf;
DWORD result=0;
ReadFile(read_file_handle,read_buf,sizeof(char)*512,&result,NULL);
// read_buf의 글자 사이사이에 있는 NULL값 제거 ( UTF8ToANSI 에서 strlen을 사용하기 때문)
int j=0;
for(int i=0;i<256;i++){
if(read_buf[i] != '\0'){
buf_noNull[j++] = read_buf[i];
}
}
buf_noNull[j]='\0';
// 출력
ansi_buf=UTF8ToANSI(buf_noNull);
printf("%s\n",ansi_buf);
CloseHandle(read_file_handle);
/* MMIO()을 통한 읽기 후 출력*/
read_file_handle = CreateFileW(
copy_file_name,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
0,
NULL);
if(read_file_handle == INVALID_HANDLE_VALUE)
{
print("err, CreateFile(path=%ws), gle=0x%08x", read_file_handle, GetLastError());
return false;
}
HANDLE file_map = CreateFileMapping(
read_file_handle,
NULL,
PAGE_READONLY,
0,
0,
NULL
);
if (NULL == file_map)
{
print("err, CreateFileMapping(%ws) failed, gle = %u", file_name, GetLastError());
CloseHandle(read_file_handle);
return false;
}
PCHAR file_view = (PCHAR) MapViewOfFile(
file_map,
FILE_MAP_READ,
0,
0,
0
);
if(file_view == NULL)
{
print("err, MapViewOfFile(%ws) failed, gle = %u", file_name, GetLastError());
CloseHandle(file_map);
CloseHandle(read_file_handle);
return false;
}
// read_buf의 글자 사이사이에 있는 NULL값 제거 ( UTF8ToANSI 에서 strlen을 사용하기 때문)
j=0;
for(int i=0;i<256;i++){
if(read_buf[i] != '\0'){
buf_noNull[j++] = file_view[i];
}
}
buf_noNull[j]='\0';
// 출력
ansi_buf=UTF8ToANSI(buf_noNull);
printf("%s\n",ansi_buf);
UnmapViewOfFile(file_view);
CloseHandle(file_map);
CloseHandle(read_file_handle);
/* BOB.txt 파일 삭제*/
::DeleteFileW(file_name);
return true;
}
// печатает в буфер key_name_buffer текстовое описание нажатой комбинации кнопок
// Кодировка ANSI (для экономии места, всё равно названия клавиш английские)
VOID HwHotKeys_PrintFullKeyname(DWORD scancode)
{
key_name_buffer[0] = 0;
if (!scancode) // если нулевой сканкод - то пустую строку делаем.
{
return;
}
if (scancode & key_flag_sl) // L_Shift
{
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_SL);
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + ");
}
if (scancode & key_flag_sr) // R_Shift
{
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_SR);
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + ");
}
if (scancode & key_flag_ss) // Shift
{
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_SS);
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + ");
}
if (scancode & key_flag_cl) // L_Ctrl
{
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_CL);
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + ");
}
if (scancode & key_flag_cr) // R_Ctrl
{
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_CR);
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + ");
}
if (scancode & key_flag_cc) // Ctrl
{
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_CC);
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + ");
}
if (scancode & key_flag_al) // L_Alt
{
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_AL);
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + ");
}
if (scancode & key_flag_ar) // R_Alt
{
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_AR);
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + ");
}
if (scancode & key_flag_aa) // Alt
{
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_AA);
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + ");
}
if (scancode & key_flag_wl) // L_Win
{
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_WL);
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + ");
}
if (scancode & key_flag_wr) // R_Win
{
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_WR);
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + ");
}
if (scancode & key_flag_ww) // Win
{
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), t_WW);
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), " + ");
}
if ((scancode & 0x1FF) < sizeof(key_tab)) // защита от ошибочных данных - чтобы не выйти из таблицы имён.
{
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), key_tab[(scancode & 0x1FF)]);
}
else
{
StringCbCatA(key_name_buffer, sizeof(key_name_buffer), "out of range");
}
INT_PTR tmp1 = mir_strlen(key_name_buffer); // допечатываем в конеце строки сканкод - для удобства работы с пока ещё не известными (безимянными) кнопками
StringCbPrintfA(key_name_buffer + tmp1, sizeof(key_name_buffer) - tmp1, " (%03X)", (scancode & 0x1FF));
return;
}
static LRESULT CALLBACK
MainWindowProc(HWND MainWindow, UINT Message, WPARAM wParam, LPARAM lParam)
{
LRESULT Result = 0;
switch(Message) {
case WM_CREATE:
InitWindowComponents(MainWindow, &Controls);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
case WM_ERASEBKGND:
// NOTE: Return a non-zero value. Literally.
Result = !0;
break;
case WM_PAINT:
{
PAINTSTRUCT PaintStruct;
HDC DC = BeginPaint(MainWindow, &PaintStruct);
RECT FillRegion;
GetClientRect(MainWindow, &FillRegion);
COLORREF Top = RGB(239, 241, 245);
COLORREF Bottom = RGB(218, 223, 233);
DrawGradient(DC, FillRegion, Top, Top, Bottom, Bottom);
EndPaint(MainWindow, &PaintStruct);
ReleaseDC(MainWindow, DC);
} break;
case WM_COMMAND:
{
HWND Ctrl = (HWND)lParam;
if(HIWORD(wParam) == CBN_SELCHANGE && Ctrl == Controls.ComboBox) {
DWORD Pos = SendMessageA((HWND)lParam, CB_GETCURSEL, 0, 0);
window_data *WndData = (window_data*)SendMessageA((HWND)lParam, CB_GETITEMDATA, Pos, 0);
if(WndData) {
Controls.CurSelection = WndData;
HWND Window = WndData->Window;
WINDOWINFO WindowInfo = {};
WindowInfo.cbSize = sizeof(WindowInfo);
if(GetWindowInfo(Window, &WindowInfo)) {
RECT Rect = WindowInfo.rcWindow;
LONG Width = Rect.right - Rect.left;
LONG Height = Rect.bottom - Rect.top;
// TODO: Display usefull data
char Buffer[256];
StringCbPrintfA(Buffer, sizeof(Buffer), "%dx%d starting at (%d,%d)", Width, Height, Rect.left, Rect.top);
SetWindowTextA(Controls.StaticText, Buffer);
ShowWindow(Controls.StaticText, TRUE);
}
else {
PRINT_ERR("Could not get window info.\n");
}
}
}
else if(HIWORD(wParam) == BN_CLICKED) {
if(Ctrl == Controls.ButtonOK) {
if(Controls.CurSelection) {
int UseConfig = SendMessageA(Controls.CheckBox, BM_GETCHECK, 0, 0);
if(UseConfig == BST_CHECKED) {
load_file_result LoadResult = LoadWindowSizeFromConfig();
if(LoadResult.Valid) {
SetWindowMode(*Controls.CurSelection, LoadResult.Width, LoadResult.Height);
}
else {
int SetToFullscreen = MessageBoxA(MainWindow, "Error loading config.ini.\nSet to fullscreen instead?", 0, MB_YESNO | MB_TASKMODAL);
if(SetToFullscreen == IDYES) {
SetFullscreen(*Controls.CurSelection);
}
}
}
else {
SetFullscreen(*Controls.CurSelection);
}
}
PostQuitMessage(0);
}
else if(Ctrl == Controls.ButtonCancel) {
PostQuitMessage(0);
}
else {
Result = DefWindowProcA(MainWindow, Message, wParam, lParam);
}
}
} break;
default:
Result = DefWindowProcA(MainWindow, Message, wParam, lParam);
}
return Result;
}
// Creates a volume header in memory
int CreateVolumeHeaderInMemory (HWND hwndDlg, BOOL bBoot, char *header, int ea, int mode, Password *password,
int pkcs5_prf, char *masterKeydata, PCRYPTO_INFO *retInfo,
unsigned __int64 volumeSize, unsigned __int64 hiddenVolumeSize,
unsigned __int64 encryptedAreaStart, unsigned __int64 encryptedAreaLength, uint16 requiredProgramVersion, uint32 headerFlags, uint32 sectorSize, BOOL bWipeMode)
{
unsigned char *p = (unsigned char *) header;
static KEY_INFO keyInfo;
int nUserKeyLen = password->Length;
PCRYPTO_INFO cryptoInfo = crypto_open ();
static char dk[MASTER_KEYDATA_SIZE];
int x;
int retVal = 0;
int primaryKeyOffset;
if (cryptoInfo == NULL)
return ERR_OUTOFMEMORY;
memset (header, 0, TC_VOLUME_HEADER_EFFECTIVE_SIZE);
VirtualLock (&keyInfo, sizeof (keyInfo));
VirtualLock (&dk, sizeof (dk));
/* Encryption setup */
if (masterKeydata == NULL)
{
// We have no master key data (creating a new volume) so we'll use the TrueCrypt RNG to generate them
int bytesNeeded;
switch (mode)
{
default:
bytesNeeded = EAGetKeySize (ea) * 2; // Size of primary + secondary key(s)
}
if (!RandgetBytes (hwndDlg, keyInfo.master_keydata, bytesNeeded, TRUE))
return ERR_CIPHER_INIT_WEAK_KEY;
}
else
{
// We already have existing master key data (the header is being re-encrypted)
memcpy (keyInfo.master_keydata, masterKeydata, MASTER_KEYDATA_SIZE);
}
// User key
memcpy (keyInfo.userKey, password->Text, nUserKeyLen);
keyInfo.keyLength = nUserKeyLen;
keyInfo.noIterations = get_pkcs5_iteration_count (pkcs5_prf, FALSE, bBoot);
// User selected encryption algorithm
cryptoInfo->ea = ea;
// User selected PRF
cryptoInfo->pkcs5 = pkcs5_prf;
cryptoInfo->bTrueCryptMode = FALSE;
// Mode of operation
cryptoInfo->mode = mode;
// Salt for header key derivation
if (!RandgetBytes (hwndDlg, keyInfo.salt, PKCS5_SALT_SIZE, !bWipeMode))
return ERR_CIPHER_INIT_WEAK_KEY;
// PBKDF2 (PKCS5) is used to derive primary header key(s) and secondary header key(s) (XTS) from the password/keyfiles
switch (pkcs5_prf)
{
case SHA512:
derive_key_sha512 (keyInfo.userKey, keyInfo.keyLength, keyInfo.salt,
PKCS5_SALT_SIZE, keyInfo.noIterations, dk, GetMaxPkcs5OutSize());
break;
case SHA256:
derive_key_sha256 (keyInfo.userKey, keyInfo.keyLength, keyInfo.salt,
PKCS5_SALT_SIZE, keyInfo.noIterations, dk, GetMaxPkcs5OutSize());
break;
case RIPEMD160:
derive_key_ripemd160 (keyInfo.userKey, keyInfo.keyLength, keyInfo.salt,
PKCS5_SALT_SIZE, keyInfo.noIterations, dk, GetMaxPkcs5OutSize());
break;
case WHIRLPOOL:
derive_key_whirlpool (keyInfo.userKey, keyInfo.keyLength, keyInfo.salt,
PKCS5_SALT_SIZE, keyInfo.noIterations, dk, GetMaxPkcs5OutSize());
break;
default:
// Unknown/wrong ID
TC_THROW_FATAL_EXCEPTION;
}
/* Header setup */
// Salt
mputBytes (p, keyInfo.salt, PKCS5_SALT_SIZE);
// Magic
mputLong (p, 0x56455241);
// Header version
mputWord (p, VOLUME_HEADER_VERSION);
cryptoInfo->HeaderVersion = VOLUME_HEADER_VERSION;
// Required program version to handle this volume
mputWord (p, requiredProgramVersion != 0 ? requiredProgramVersion : TC_VOLUME_MIN_REQUIRED_PROGRAM_VERSION);
// CRC of the master key data
x = GetCrc32(keyInfo.master_keydata, MASTER_KEYDATA_SIZE);
mputLong (p, x);
// Reserved fields
p += 2 * 8;
// Size of hidden volume (if any)
cryptoInfo->hiddenVolumeSize = hiddenVolumeSize;
mputInt64 (p, cryptoInfo->hiddenVolumeSize);
cryptoInfo->hiddenVolume = cryptoInfo->hiddenVolumeSize != 0;
// Volume size
cryptoInfo->VolumeSize.Value = volumeSize;
mputInt64 (p, volumeSize);
// Encrypted area start
cryptoInfo->EncryptedAreaStart.Value = encryptedAreaStart;
mputInt64 (p, encryptedAreaStart);
// Encrypted area size
cryptoInfo->EncryptedAreaLength.Value = encryptedAreaLength;
mputInt64 (p, encryptedAreaLength);
// Flags
cryptoInfo->HeaderFlags = headerFlags;
mputLong (p, headerFlags);
// Sector size
if (sectorSize < TC_MIN_VOLUME_SECTOR_SIZE
|| sectorSize > TC_MAX_VOLUME_SECTOR_SIZE
|| sectorSize % ENCRYPTION_DATA_UNIT_SIZE != 0)
{
TC_THROW_FATAL_EXCEPTION;
}
cryptoInfo->SectorSize = sectorSize;
mputLong (p, sectorSize);
// CRC of the header fields
x = GetCrc32 (header + TC_HEADER_OFFSET_MAGIC, TC_HEADER_OFFSET_HEADER_CRC - TC_HEADER_OFFSET_MAGIC);
p = header + TC_HEADER_OFFSET_HEADER_CRC;
mputLong (p, x);
// The master key data
memcpy (header + HEADER_MASTER_KEYDATA_OFFSET, keyInfo.master_keydata, MASTER_KEYDATA_SIZE);
/* Header encryption */
switch (mode)
{
default:
// The secondary key (if cascade, multiple concatenated)
memcpy (cryptoInfo->k2, dk + EAGetKeySize (cryptoInfo->ea), EAGetKeySize (cryptoInfo->ea));
primaryKeyOffset = 0;
}
retVal = EAInit (cryptoInfo->ea, dk + primaryKeyOffset, cryptoInfo->ks);
if (retVal != ERR_SUCCESS)
return retVal;
// Mode of operation
if (!EAInitMode (cryptoInfo))
return ERR_OUTOFMEMORY;
// Encrypt the entire header (except the salt)
EncryptBuffer (header + HEADER_ENCRYPTED_DATA_OFFSET,
HEADER_ENCRYPTED_DATA_SIZE,
cryptoInfo);
/* cryptoInfo setup for further use (disk format) */
// Init with the master key(s)
retVal = EAInit (cryptoInfo->ea, keyInfo.master_keydata + primaryKeyOffset, cryptoInfo->ks);
if (retVal != ERR_SUCCESS)
return retVal;
memcpy (cryptoInfo->master_keydata, keyInfo.master_keydata, MASTER_KEYDATA_SIZE);
switch (cryptoInfo->mode)
{
default:
// The secondary master key (if cascade, multiple concatenated)
memcpy (cryptoInfo->k2, keyInfo.master_keydata + EAGetKeySize (cryptoInfo->ea), EAGetKeySize (cryptoInfo->ea));
}
// Mode of operation
if (!EAInitMode (cryptoInfo))
return ERR_OUTOFMEMORY;
#ifdef VOLFORMAT
if (showKeys && !bInPlaceEncNonSys)
{
BOOL dots3 = FALSE;
int i, j;
j = EAGetKeySize (ea);
if (j > NBR_KEY_BYTES_TO_DISPLAY)
{
dots3 = TRUE;
j = NBR_KEY_BYTES_TO_DISPLAY;
}
MasterKeyGUIView[0] = 0;
for (i = 0; i < j; i++)
{
char tmp2[8] = {0};
StringCbPrintfA (tmp2, sizeof(tmp2), "%02X", (int) (unsigned char) keyInfo.master_keydata[i + primaryKeyOffset]);
StringCbCatA (MasterKeyGUIView, sizeof(MasterKeyGUIView), tmp2);
}
HeaderKeyGUIView[0] = 0;
for (i = 0; i < NBR_KEY_BYTES_TO_DISPLAY; i++)
{
char tmp2[8];
StringCbPrintfA (tmp2, sizeof(tmp2), "%02X", (int) (unsigned char) dk[primaryKeyOffset + i]);
StringCbCatA (HeaderKeyGUIView, sizeof(HeaderKeyGUIView), tmp2);
}
if (dots3)
{
DisplayPortionsOfKeys (hHeaderKey, hMasterKey, HeaderKeyGUIView, MasterKeyGUIView, !showKeys);
}
else
{
SendMessage (hMasterKey, WM_SETTEXT, 0, (LPARAM) MasterKeyGUIView);
SendMessage (hHeaderKey, WM_SETTEXT, 0, (LPARAM) HeaderKeyGUIView);
}
}
#endif // #ifdef VOLFORMAT
burn (dk, sizeof(dk));
burn (&keyInfo, sizeof (keyInfo));
*retInfo = cryptoInfo;
return 0;
}
LPSTR err_describe(LPSTR buf, size_t len, long code)
{
LPSTR cp, com_err_msg;
int offset;
long table_num;
char *etype;
offset = (int) (code & 255);
table_num = code - offset;
com_err_msg = Lerror_message(code);
switch(table_num)
{
case krb_err_base:
case kadm_err_base:
break;
default:
StringCbCopyA(buf, len, com_err_msg);
return buf;
}
cp = buf;
if (table_num == krb_err_base)
switch(offset)
{
case KDC_NAME_EXP: /* 001 Principal expired */
case KDC_SERVICE_EXP: /* 002 Service expired */
case KDC_AUTH_EXP: /* 003 Auth expired */
case KDC_PKT_VER: /* 004 Protocol version unknown */
case KDC_P_MKEY_VER: /* 005 Wrong master key version */
case KDC_S_MKEY_VER: /* 006 Wrong master key version */
case KDC_BYTE_ORDER: /* 007 Byte order unknown */
case KDC_PR_N_UNIQUE: /* 009 Principal not unique */
case KDC_NULL_KEY: /* 010 Principal has null key */
case KDC_GEN_ERR: /* 011 Generic error from KDC */
case INTK_W_NOTALL : /* 061 Not ALL tickets returned */
case INTK_PROT : /* 063 Protocol Error */
case INTK_ERR : /* 070 Other error */
com_err_msg = "Something weird happened... try again, and if Leash"
" continues to fail, contact Network Services as listed in the "
"About box.";
break;
case KDC_PR_UNKNOWN: /* 008 Principal unknown */
com_err_msg = "You have entered an unknown username/instance/realm"
" combination.";
break;
case GC_TKFIL : /* 021 Can't read ticket file */
case GC_NOTKT : /* 022 Can't find ticket or TGT */
com_err_msg = "Something is wrong with the memory where your "
"tickets are stored. Try exiting Windows and restarting your "
"computer.";
break;
case MK_AP_TGTEXP : /* 026 TGT Expired */
/* no extra error msg */
break;
case RD_AP_TIME : /* 037 delta_t too big */
com_err_msg = "Your computer's clock is out of sync with the "
"Kerberos server. Please see the help file about correcting "
"your clock.";
break;
case RD_AP_UNDEC : /* 031 Can't decode authenticator */
case RD_AP_EXP : /* 032 Ticket expired */
case RD_AP_NYV : /* 033 Ticket not yet valid */
case RD_AP_REPEAT : /* 034 Repeated request */
case RD_AP_NOT_US : /* 035 The ticket isn't for us */
case RD_AP_INCON : /* 036 Request is inconsistent */
case RD_AP_BADD : /* 038 Incorrect net address */
case RD_AP_VERSION : /* 039 protocol version mismatch */
case RD_AP_MSG_TYPE : /* 040 invalid msg type */
case RD_AP_MODIFIED : /* 041 message stream modified */
case RD_AP_ORDER : /* 042 message out of order */
case RD_AP_UNAUTHOR : /* 043 unauthorized request */
/* no extra error msg */
break;
case GT_PW_NULL: /* 51 Current PW is null */
case GT_PW_BADPW: /* 52 Incorrect current password */
case GT_PW_PROT: /* 53 Protocol Error */
case GT_PW_KDCERR: /* 54 Error returned by KDC */
case GT_PW_NULLTKT: /* 55 Null tkt returned by KDC */
/* no error msg yet */
break;
/* Values returned by send_to_kdc */
case SKDC_RETRY : /* 56 Retry count exceeded */
case SKDC_CANT : /* 57 Can't send request */
com_err_msg = "Cannot contact the kerberos server for the selected realm.";
break;
/* no error message on purpose: */
case INTK_BADPW : /* 062 Incorrect password */
break;
default:
/* no extra error msg */
break;
}
else
switch(code)
{
case KADM_INSECURE_PW:
/* if( kadm_info != NULL ){
* wsprintf(buf, "%s\n%s", com_err_msg, kadm_info);
* } else {
* wsprintf(buf, "%s\nPlease see the help file for information "
* "about secure passwords.", com_err_msg);
* }
* com_err_msg = buf;
*/
/* The above code would be preferred since it allows site specific
* information to be delivered from the Kerberos server. However the
* message box is too small for VGA screens.
* It does work well if we only have to support 1024x768
*/
com_err_msg = "You have entered an insecure or weak password.";
default:
/* no extra error msg */
break;
}
if(com_err_msg != buf) {
StringCbCopyA(buf, len, com_err_msg);
}
cp = buf + strlen(buf);
*cp++ = '\n';
switch(table_num) {
case krb_err_base:
etype = "Kerberos";
break;
case kadm_err_base:
etype = "Kerberos supplemental";
break;
default:
etype = Lerror_table_name(table_num);
break;
}
StringCbPrintfA((LPSTR) cp, len - (cp-buf), (LPSTR) "(%s error %d"
#ifdef DEBUG_COM_ERR
" (absolute error %ld)"
#endif
")", etype, offset
//")\nPress F1 for help on this error.", etype, offset
#ifdef DEBUG_COM_ERR
, code
#endif
);
return (LPSTR)buf;
}
void GetRestorePointRegKeyName (char *regk, size_t cbRegk)
{
// The string is split in order to prevent some antivirus packages from falsely reporting
// VeraCrypt.exe to contain a possible Trojan horse because of this string (heuristic scan).
StringCbPrintfA (regk, cbRegk,"%s%s%s%s", "Software\\Microsoft\\Windows", " NT\\Curren", "tVersion\\Sy", "stemRestore");
}
NTSTATUS Log_Print(LOG_LEVEL Level, LPCSTR pszFormat, ...)
{
NTSTATUS Status = STATUS_SUCCESS;
LARGE_INTEGER SystemTime, LocalTime;
TIME_FIELDS TimeFields;
PLOG_COUNTED_STRING Line = NULL;
va_list args;
KIRQL Irql = KeGetCurrentIrql();
LPCSTR StrLevel = " :";
if (!LogFile)
return STATUS_INVALID_DEVICE_STATE;
if (Irql > DISPATCH_LEVEL)
return STATUS_INVALID_LEVEL;
KeQuerySystemTime(&SystemTime);
ExSystemTimeToLocalTime(&SystemTime, &LocalTime);
RtlTimeToTimeFields(&LocalTime, &TimeFields);
Line = ExAllocatePoolWithTag(NonPagedPool, MAX_LOG_STRING_SIZE + FIELD_OFFSET(LOG_COUNTED_STRING, Data), LogAllocationTag);
if (!Line)
return STATUS_INSUFFICIENT_RESOURCES;
switch (Level)
{
case LL_FATAL:
#if DBG
DbgBreakPointWithStatus(DBG_STATUS_FATAL);
#endif
StrLevel = "FATAL :";
break;
case LL_ERROR:
StrLevel = "ERROR :";
break;
case LL_WARNING:
StrLevel = "WARNING:";
break;
case LL_INFO:
StrLevel = "INFO :";
break;
case LL_VERBOSE:
StrLevel = "VERBOSE:";
break;
case LL_DEBUG:
StrLevel = "DEBUG :";
break;
}
Status = StringCbPrintfA(Line->Data, MAX_LOG_STRING_SIZE, "%04u.%02u.%02u %02u:%02u:%02u.%03u PR:0x%04X TH:0x%04X IL:%d %s ",
TimeFields.Year,
TimeFields.Month,
TimeFields.Day,
TimeFields.Hour,
TimeFields.Minute,
TimeFields.Second,
TimeFields.Milliseconds,
(ULONG)PsGetCurrentProcessId() & 0xFFFF,
(ULONG)PsGetCurrentThreadId() & 0xFFFF,
(ULONG)Irql,
StrLevel);
if (SUCCEEDED(Status))
{
va_start(args, pszFormat);
Line->DataLength = (USHORT)strlen(Line->Data);
Status = StringCbVPrintfA(Line->Data + Line->DataLength, MAX_LOG_STRING_SIZE - Line->DataLength, pszFormat, args);
if (SUCCEEDED(Status))
{
Line->DataLength = (USHORT)strlen(Line->Data);
if (Irql != PASSIVE_LEVEL) {
PIO_WORKITEM pWorkItem = IoAllocateWorkItem(LogDeviceObject);
InterlockedIncrement(&LogScheduledPrints);
IoQueueWorkItemEx(pWorkItem, Log_WriteWorker, DelayedWorkQueue, Line);
Status = STATUS_PENDING;
}
else
{
Status = Log_WriteLine(Line);
}
}
va_end(args);
}
if (Status != STATUS_PENDING)
ExFreePoolWithTag(Line, LogAllocationTag);
return Status;
}
bool create_bob_txt()
{
// current directory 를 구한다.
wchar_t *buf=NULL;
uint32_t buflen = 0;
buflen = GetCurrentDirectoryW(buflen, buf);
if (0 == buflen)
{
print("err, GetCurrentDirectoryW() failed. gle = 0x%08x", GetLastError());
return false;
}
buf = (PWSTR) malloc(sizeof(WCHAR) * buflen);
if (0 == GetCurrentDirectoryW(buflen, buf))
{
print("err, GetCurrentDirectoryW() failed. gle = 0x%08x", GetLastError());
free(buf);
return false;
}
// current dir \\ bob.txt 파일명 생성
wchar_t file_name[260];
if (!SUCCEEDED(StringCbPrintfW(
file_name,
sizeof(file_name),
L"%ws\\bob.txt",
buf)))
{
print("err, can not create file name");
free(buf);
return false;
}
free(buf); buf = NULL;
if (true == is_file_existsW(file_name))
{
::DeleteFileW(file_name);
}
// 파일 생성
HANDLE file_handle = CreateFileW(
file_name,
GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
CREATE_NEW,
FILE_ATTRIBUTE_NORMAL,
NULL);
if(file_handle == INVALID_HANDLE_VALUE)
{
print("err, CreateFile(path=%ws), gle=0x%08x", file_name, GetLastError());
return false;
}
// 파일에 데이터 쓰기
DWORD bytes_written = 0;
wchar_t string_buf[1024];
if (!SUCCEEDED(StringCbPrintfW(
string_buf,
sizeof(string_buf),
L"동해물과 백두산이 마르고 닳도록 하느님이 보우하사 우리나라만세")))
{
print("err, can not create data to write.");
CloseHandle(file_handle);
return false;
}
if (!WriteFile(file_handle, string_buf, wcslen(string_buf), &bytes_written, NULL))
{
print("err, WriteFile() failed. gle = 0x%08x", GetLastError());
CloseHandle(file_handle);
return false;
}
// 영어로 쓰기
if (!SUCCEEDED(StringCbPrintfW(
string_buf,
sizeof(string_buf),
L"All work and no play makes jack a dull boy.")))
{
print("err, can not create data to write.");
CloseHandle(file_handle);
return false;
}
if (!WriteFile(file_handle, string_buf, wcslen(string_buf), &bytes_written, NULL))
{
print("err, WriteFile() failed. gle = 0x%08x", GetLastError());
CloseHandle(file_handle);
return false;
}
char string_bufa[1024];
if (!SUCCEEDED(StringCbPrintfA(
string_bufa,
sizeof(string_bufa),
"동해물과 백두산이 마르고 닳도록 하느님이 보우하사 우리나라만세")))
{
print("err, can not create data to write.");
CloseHandle(file_handle);
return false;
}
if (!WriteFile(file_handle, string_bufa, strlen(string_bufa), &bytes_written, NULL))
{
print("err, WriteFile() failed. gle = 0x%08x", GetLastError());
CloseHandle(file_handle);
return false;
}
// 영어로 쓰기
if (!SUCCEEDED(StringCbPrintfA(
string_bufa,
sizeof(string_bufa),
"All work and no play makes jack a dull boy.")))
{
print("err, can not create data to write.");
CloseHandle(file_handle);
return false;
}
if (!WriteFile(file_handle, string_bufa, strlen(string_bufa), &bytes_written, NULL))
{
print("err, WriteFile() failed. gle = 0x%08x", GetLastError());
CloseHandle(file_handle);
return false;
}
// 파일 닫기
CloseHandle(file_handle);
return true;
}
/* Returns TRUE if the key is allowed and its name is resolved. */
BOOL GetKeyName (UINT vKey, wchar_t *keyName)
{
BOOL result = TRUE;
if (vKey >= 0x30 && vKey <= 0x5a)
{
// ASCII characters
StringCbPrintfW (keyName, MAX_KEY_COMB_NAME_LEN, L"%hc", (char) vKey);
}
else if (vKey >= 0xE9 && vKey <= 0xF5)
{
// OEM-specific
StringCbPrintfW (keyName, MAX_KEY_COMB_NAME_LEN, L"OEM-%d", vKey);
// mapping taken from:
// http://www.hotkeynet.com/ref/keynames.html
// https://mojoware.googlecode.com/svn-history/r3/trunk/mojo_engine/cKeyboard.cpp
// http://www.screenio.com/gui_screenio/gs_htmlhelp_subweb/download/SIMKEYS.cob
//
// These values seem to come from Nokia/Ericsson mobile device keys
switch (vKey)
{
case 0xE9: // OEMReset = 0xE9
StringCbCatW (keyName, MAX_KEY_COMB_NAME_LEN, L" (OEMReset)");
break;
case 0xEA: // OEMJump = 0xEA
StringCbCatW (keyName, MAX_KEY_COMB_NAME_LEN, L" (OEMJump)");
break;
case 0xEB: // OEMPA1 = 0xEB
StringCbCatW (keyName, MAX_KEY_COMB_NAME_LEN, L" (OEMPA1)");
break;
case 0xEC: // OEMPA2 = 0xEC
StringCbCatW (keyName, MAX_KEY_COMB_NAME_LEN, L" (OEMPA2)");
break;
case 0xED: // OEMPA3 = 0xED
StringCbCatW (keyName, MAX_KEY_COMB_NAME_LEN, L" (OEMPA3)");
break;
case 0xEE: // OEMWSCtrl = 0xEE
StringCbCatW (keyName, MAX_KEY_COMB_NAME_LEN, L" (OEMWSCtrl)");
break;
case 0xEF: // OEMCUSel = 0xEF
StringCbCatW (keyName, MAX_KEY_COMB_NAME_LEN, L" (OEMCUSel)");
break;
case 0xF0: // OEMATTN = 0xF0
StringCbCatW (keyName, MAX_KEY_COMB_NAME_LEN, L" (OEMATTN)");
break;
case 0xF1: // OEMFinish = 0xF1
StringCbCatW (keyName, MAX_KEY_COMB_NAME_LEN, L" (OEMFinish)");
break;
case 0xF2: // OEMCopy = 0xF2
StringCbCatW (keyName, MAX_KEY_COMB_NAME_LEN, L" (OEMCopy)");
break;
case 0xF3: // OEMAuto = 0xF3
StringCbCatW (keyName, MAX_KEY_COMB_NAME_LEN, L" (OEMAuto)");
break;
case 0xF4: // OEMENLW = 0xF4
StringCbCatW (keyName, MAX_KEY_COMB_NAME_LEN, L" (OEMENLW)");
break;
case 0xF5: // OEMBackTab = 0xF5
StringCbCatW (keyName, MAX_KEY_COMB_NAME_LEN, L" (OEMBackTab)");
break;
}
}
else if (vKey >= VK_F1 && vKey <= VK_F24)
{
// F1-F24
StringCbPrintfW (keyName, MAX_KEY_COMB_NAME_LEN, L"F%d", vKey - VK_F1 + 1);
}
else if (vKey >= VK_NUMPAD0 && vKey <= VK_NUMPAD9)
{
// Numpad numbers
StringCbPrintfW (keyName, MAX_KEY_COMB_NAME_LEN, L"%s %d", GetString ("VK_NUMPAD"), vKey - VK_NUMPAD0);
}
else
{
switch (vKey)
{
case VK_MULTIPLY: StringCbPrintfW (keyName, MAX_KEY_COMB_NAME_LEN, L"%s *", GetString ("VK_NUMPAD")); break;
case VK_ADD: StringCbPrintfW (keyName, MAX_KEY_COMB_NAME_LEN, L"%s +", GetString ("VK_NUMPAD")); break;
case VK_SEPARATOR: StringCbPrintfW (keyName, MAX_KEY_COMB_NAME_LEN, L"%s Separator", GetString ("VK_NUMPAD")); break;
case VK_SUBTRACT: StringCbPrintfW (keyName, MAX_KEY_COMB_NAME_LEN, L"%s -", GetString ("VK_NUMPAD")); break;
case VK_DECIMAL: StringCbPrintfW (keyName, MAX_KEY_COMB_NAME_LEN, L"%s .", GetString ("VK_NUMPAD")); break;
case VK_DIVIDE: StringCbPrintfW (keyName, MAX_KEY_COMB_NAME_LEN, L"%s /", GetString ("VK_NUMPAD")); break;
case VK_OEM_1: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"OEM 1 (';')"); break;
case VK_OEM_PLUS: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"+"); break;
case VK_OEM_COMMA: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L","); break;
case VK_OEM_MINUS: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"-"); break;
case VK_OEM_PERIOD: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"."); break;
case VK_OEM_2: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"OEM 2 ('/')"); break;
case VK_OEM_3: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"OEM 3 (`)"); break;
case VK_OEM_4: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"OEM 4 ('[')"); break;
case VK_OEM_5: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"OEM 5 ('\\')"); break;
case VK_OEM_6: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"OEM 6 (']')"); break;
case VK_OEM_7: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"OEM 7 (')"); break;
case VK_OEM_8: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"OEM 8"); break;
case VK_OEM_AX: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"OEM AX"); break;
case VK_OEM_102: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"OEM 102"); break;
case VK_ICO_HELP: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"ICO_HELP"); break;
case VK_ICO_00: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"ICO_00"); break;
case VK_ICO_CLEAR: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"ICO_CLEAR"); break;
case VK_ATTN: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"Attn"); break;
case VK_CRSEL: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"CrSel"); break;
case VK_EXSEL: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"ExSel"); break;
case VK_EREOF: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"Erase EOF"); break;
case VK_PA1: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"PA1"); break;
case VK_OEM_CLEAR: StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, L"OEM Clear"); break;
case 0:
case 1:
case 0xFF:
result = FALSE;
break;
default:
{
char key[16];
wchar_t *desc;
StringCbPrintfA (key, sizeof(key),"VKEY_%02X", vKey);
desc = GetString (key);
if (desc == UnknownString)
result = FALSE;
else
StringCbCopyW (keyName, MAX_KEY_COMB_NAME_LEN, desc);
}
}
}
return result;
}
