/* * OpenVPN-GUI -- A Windows GUI for OpenVPN. * * Copyright (C) 2013 Heiko Hund * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program (see the file COPYING included with this * distribution); if not, write to the Free Software Foundation, Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include #include #include #include #include #include #include #include "localization.h" #include "options.h" #include "manage.h" #include "main.h" #include "misc.h" #include "main.h" #include "openvpn_config.h" #include "openvpn-gui-res.h" #include "tray.h" #include "config_parser.h" /* * Helper function to do base64 conversion through CryptoAPI * Returns TRUE on success, FALSE on error. Caller must free *output. */ BOOL Base64Encode(const char *input, int input_len, char **output) { DWORD output_len; DWORD flags = CRYPT_STRING_BASE64|CRYPT_STRING_NOCRLF; if (input_len == 0) { /* set output to empty string -- matches the behavior in openvpn */ *output = calloc(1, sizeof(char)); return TRUE; } if (!CryptBinaryToStringA((const BYTE *) input, (DWORD) input_len, flags, NULL, &output_len) || output_len == 0) { #ifdef DEBUG PrintDebug(L"Error in CryptBinaryToStringA: input = '%.*hs'", input_len, input); #endif *output = NULL; return FALSE; } *output = (char *)malloc(output_len); if (*output == NULL) { return FALSE; } if (!CryptBinaryToStringA((const BYTE *) input, (DWORD) input_len, flags, *output, &output_len)) { #ifdef DEBUG PrintDebug(L"Error in CryptBinaryToStringA: input = '%.*hs'", input_len, input); #endif free(*output); *output = NULL; return FALSE; } return TRUE; } /* * Decode a nul-terminated base64 encoded input and save the result in * an allocated buffer *output. The caller must free *output after use. * The decoded output is nul-terminated so that the caller may treat * it as a string when appropriate. * * Return the length of the decoded result (excluding nul) or -1 on * error. */ int Base64Decode(const char *input, char **output) { DWORD len; PrintDebug(L"decoding %hs", input); if (!CryptStringToBinaryA(input, 0, CRYPT_STRING_BASE64_ANY, NULL, &len, NULL, NULL) || len == 0) { *output = NULL; return -1; } *output = malloc(len + 1); if (*output == NULL) { return -1; } if (!CryptStringToBinaryA(input, 0, CRYPT_STRING_BASE64, (BYTE *) *output, &len, NULL, NULL)) { free(*output); *output = NULL; return -1; } /* NUL terminate output */ (*output)[len] = '\0'; PrintDebug(L"Decoded output %hs", *output); return len; } BOOL GetDlgItemTextUtf8(HWND hDlg, int id, LPSTR *str, int *len) { int ucs2_len, utf8_len; BOOL retval = FALSE; LPTSTR ucs2_str = NULL; LPSTR utf8_str = NULL; *str = ""; *len = 0; ucs2_len = GetWindowTextLength(GetDlgItem(hDlg, id)) + 1; if (ucs2_len == 1) { goto out; } ucs2_str = malloc(ucs2_len * sizeof(*ucs2_str)); if (ucs2_str == NULL) { goto out; } if (GetDlgItemText(hDlg, id, ucs2_str, ucs2_len) == 0) { goto out; } utf8_len = WideCharToMultiByte(CP_UTF8, 0, ucs2_str, -1, NULL, 0, NULL, NULL); utf8_str = malloc(utf8_len); if (utf8_str == NULL) { goto out; } WideCharToMultiByte(CP_UTF8, 0, ucs2_str, -1, utf8_str, utf8_len, NULL, NULL); *str = utf8_str; *len = utf8_len - 1; retval = TRUE; out: free(ucs2_str); return retval; } /** * Escape backslash, space and double-quote in a string * @param input Pointer to the string to escape * @returns A newly allocated string containing the result or NULL * on error. Caller must free it after use. */ char * escape_string(const char *input) { char *out = strdup(input); const char *esc = "\"\\ "; if (!out) { MsgToEventLog(EVENTLOG_ERROR_TYPE, L"Error in escape_string: out of memory"); return NULL; } int len = strlen(out); for (int pos = 0; pos < len; ++pos) { if (strchr(esc, out[pos])) { char *buf = realloc(out, ++len + 1); if (buf == NULL) { free(out); MsgToEventLog(EVENTLOG_ERROR_TYPE, L"Error in escape_string: out of memory"); return NULL; } out = buf; memmove(out + pos + 1, out + pos, len - pos + 1); out[pos] = '\\'; pos += 1; } } PrintDebug(L"escape_string: in: '%hs' out: '%hs' len = %d", input, out, len); return out; } /* * Generate a management command from user input and send it */ BOOL ManagementCommandFromInput(connection_t *c, LPCSTR fmt, HWND hDlg, int id) { BOOL retval = FALSE; LPSTR input, cmd; int input_len, cmd_len; GetDlgItemTextUtf8(hDlg, id, &input, &input_len); /* Escape input if needed */ char *input_e = escape_string(input); if (!input_e) { goto out; } free(input); input = input_e; input_len = strlen(input); cmd_len = input_len + strlen(fmt); cmd = malloc(cmd_len); if (cmd) { snprintf(cmd, cmd_len, fmt, input); retval = ManagementCommand(c, cmd, NULL, regular); free(cmd); } out: /* Clear buffers with potentially secret content */ if (input_len) { memset(input, 'x', input_len); SetDlgItemTextA(hDlg, id, input); free(input); } return retval; } /* * Generate a management command from double user inputs and send it */ BOOL ManagementCommandFromTwoInputsBase64(connection_t *c, LPCSTR fmt, HWND hDlg, int id, int id2) { BOOL retval = FALSE; LPSTR input, input2, input_b64, input2_b64, cmd; int input_len, input2_len, cmd_len; input_b64 = NULL; input2_b64 = NULL; GetDlgItemTextUtf8(hDlg, id, &input, &input_len); GetDlgItemTextUtf8(hDlg, id2, &input2, &input2_len); if (!Base64Encode(input, input_len, &input_b64)) { goto out; } if (!Base64Encode(input2, input2_len, &input2_b64)) { goto out; } cmd_len = strlen(input_b64) + strlen(input2_b64) + strlen(fmt); cmd = malloc(cmd_len); if (cmd) { snprintf(cmd, cmd_len, fmt, input_b64, input2_b64); retval = ManagementCommand(c, cmd, NULL, regular); free(cmd); } out: /* Clear buffers with potentially secret content */ if (input_b64) { memset(input_b64, 0, strlen(input_b64)); } if (input2_b64) { memset(input2_b64, 0, strlen(input2_b64)); } free(input_b64); free(input2_b64); if (input_len) { memset(input, 'x', input_len); SetDlgItemTextA(hDlg, id, input); free(input); } if (input2_len) { memset(input2, 'x', input2_len); SetDlgItemTextA(hDlg, id2, input2); free(input2); } return retval; } /* * Generate a management command from base64-encoded user inputs and send it */ BOOL ManagementCommandFromInputBase64(connection_t *c, LPCSTR fmt, HWND hDlg, int id) { BOOL retval = FALSE; LPSTR input, input_b64, cmd; int input_len, cmd_len; input_b64 = NULL; GetDlgItemTextUtf8(hDlg, id, &input, &input_len); if (!Base64Encode(input, input_len, &input_b64)) { goto out; } cmd_len = strlen(input_b64) + strlen(fmt); cmd = malloc(cmd_len); if (cmd) { snprintf(cmd, cmd_len, fmt, input_b64); retval = ManagementCommand(c, cmd, NULL, regular); free(cmd); } out: /* Clear buffers with potentially secret content */ if (input_b64) { memset(input_b64, 0, strlen(input_b64)); } free(input_b64); if (input_len) { memset(input, 'x', input_len); SetDlgItemTextA(hDlg, id, input); free(input); } return retval; } /* * Ensures the given directory exists, by checking for and * creating missing parts of the path. * If the path does not exist and cannot be created return FALSE. */ BOOL EnsureDirExists(LPTSTR dir) { DWORD attr = GetFileAttributes(dir); if (attr == INVALID_FILE_ATTRIBUTES) { DWORD error = GetLastError(); if (error == ERROR_PATH_NOT_FOUND) { LPTSTR pos = _tcsrchr(dir, '\\'); if (pos == NULL) { return FALSE; } *pos = '\0'; BOOL ret = EnsureDirExists(dir); *pos = '\\'; if (ret == FALSE) { return FALSE; } } else if (error != ERROR_FILE_NOT_FOUND) { return FALSE; } /* No error if directory already exists */ return (CreateDirectory(dir, NULL) == TRUE || GetLastError() == ERROR_ALREADY_EXISTS); } return (attr & FILE_ATTRIBUTE_DIRECTORY ? TRUE : FALSE); } /* * Various string helper functions */ BOOL streq(LPCSTR str1, LPCSTR str2) { return (strcmp(str1, str2) == 0); } BOOL strbegins(const char *str, const char *begin) { return (strncmp(str, begin, strlen(begin)) == 0); } BOOL wcsbegins(LPCWSTR str, LPCWSTR begin) { return (wcsncmp(str, begin, wcslen(begin)) == 0); } /* * Force setting window as foreground window by simulating an ALT keypress */ BOOL ForceForegroundWindow(HWND hWnd) { BOOL ret = FALSE; keybd_event(VK_MENU, 0, 0, 0); ret = SetForegroundWindow(hWnd); keybd_event(VK_MENU, 0, KEYEVENTF_KEYUP, 0); return ret; } /* * Set scale factor of windows in pixels. Scale = 100% for dpi = 96 */ void DpiSetScale(options_t *options, UINT dpix) { /* scale factor in percentage compared to the reference dpi of 96 */ if (dpix != 0) { options->dpi_scale = MulDiv(dpix, 100, 96); } else { options->dpi_scale = 100; } PrintDebug(L"DPI scale set to %u", options->dpi_scale); } /* * Check user has admin rights * Taken from https://msdn.microsoft.com/en-us/library/windows/desktop/aa376389(v=vs.85).aspx * Returns true if the calling process token has the local Administrators group enabled * in its SID. Assumes the caller is not impersonating and has access to open its own * process token. */ BOOL IsUserAdmin(VOID) { BOOL b; SID_IDENTIFIER_AUTHORITY NtAuthority = {SECURITY_NT_AUTHORITY}; PSID AdministratorsGroup; b = AllocateAndInitializeSid(&NtAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &AdministratorsGroup); if (b) { if (!CheckTokenMembership(NULL, AdministratorsGroup, &b)) { b = FALSE; } FreeSid(AdministratorsGroup); } return(b); } HANDLE InitSemaphore(WCHAR *name) { HANDLE semaphore = NULL; semaphore = CreateSemaphore(NULL, 1, 1, name); if (!semaphore) { MessageBoxW(NULL, L"Error creating semaphore", TEXT(PACKAGE_NAME), MB_OK); #ifdef DEBUG PrintDebug(L"InitSemaphore: CreateSemaphore failed [error = %lu]", GetLastError()); #endif } return semaphore; } void CloseSemaphore(HANDLE sem) { if (sem) { ReleaseSemaphore(sem, 1, NULL); } CloseHandle(sem); } /* Check access rights on an existing file */ BOOL CheckFileAccess(const TCHAR *path, int access) { HANDLE h; bool ret = FALSE; h = CreateFile(path, access, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (h != INVALID_HANDLE_VALUE) { ret = TRUE; CloseHandle(h); } return ret; } /** * Convert a NUL terminated narrow string to wide string using * specified codepage. The caller must free * the returned pointer. Return NULL on error. */ WCHAR * WidenEx(UINT codepage, const char *str) { WCHAR *wstr = NULL; if (!str) { return wstr; } int nch = MultiByteToWideChar(codepage, 0, str, -1, NULL, 0); if (nch > 0) { wstr = malloc(sizeof(WCHAR) * nch); } if (wstr) { nch = MultiByteToWideChar(codepage, 0, str, -1, wstr, nch); } if (nch == 0 && wstr) { free(wstr); wstr = NULL; } return wstr; } /* * Same as WidenEx with codepage = UTF8 */ WCHAR * Widen(const char *utf8) { return WidenEx(CP_UTF8, utf8); } /* Return false if input contains any characters in exclude */ BOOL validate_input(const WCHAR *input, const WCHAR *exclude) { if (!exclude) { exclude = L"\n"; } return (wcspbrk(input, exclude) == NULL); } /* Concatenate two wide strings with a separator -- if either string is empty separator not added */ void wcs_concat2(WCHAR *dest, int len, const WCHAR *src1, const WCHAR *src2, const WCHAR *sep) { int n = 0; if (!dest || len == 0) { return; } if (src1 && src2 && src1[0] && src2[0]) { n = swprintf(dest, len, L"%ls%ls%ls", src1, sep, src2); } else if (src1 && src1[0]) { n = swprintf(dest, len, L"%ls", src1); } else if (src2 && src2[0]) { n = swprintf(dest, len, L"%ls", src2); } if (n < 0 || n >= len) /*swprintf failed */ { n = 0; } dest[n] = L'\0'; } void CloseHandleEx(LPHANDLE handle) { if (handle && *handle && *handle != INVALID_HANDLE_VALUE) { CloseHandle(*handle); *handle = INVALID_HANDLE_VALUE; } } /* * Decode url encoded characters in buffer src and * return the result in a newly allocated buffer. The * caller should free the returned pointer. Returns * NULL on memory allocation error. */ char * url_decode(const char *src) { const char *s = src; char *out = malloc(strlen(src) + 1); /* output is guaranteed to be not longer than src */ char *o; if (!out) { return NULL; } for (o = out; *s; o++) { unsigned int c = *s++; if (c == '%' && isxdigit(s[0]) && isxdigit(s[1])) { sscanf(s, "%2x", &c); s += 2; } /* We passthough all other chars including % not followed by 2 hex digits */ *o = (char)c; } *o = '\0'; return out; } DWORD md_init(md_ctx *ctx, ALG_ID hash_type) { DWORD status = 0; if (!CryptAcquireContext(&ctx->prov, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) { goto err; } if (!CryptCreateHash(ctx->prov, hash_type, 0, 0, &ctx->hash)) { CryptReleaseContext(ctx->prov, 0); goto err; } return status; err: status = GetLastError(); MsgToEventLog(EVENTLOG_ERROR_TYPE, L"Error in md_ctx_init: status = %lu", status); return status; } DWORD md_update(md_ctx *ctx, const BYTE *data, size_t size) { DWORD status = 0; if (!CryptHashData(ctx->hash, data, (DWORD)size, 0)) { status = GetLastError(); MsgToEventLog(EVENTLOG_ERROR_TYPE, L"Error in md_update: status = %lu", status); } return status; } DWORD md_final(md_ctx *ctx, BYTE *md) { DWORD status = 0; DWORD digest_len = HASHLEN; if (!CryptGetHashParam(ctx->hash, HP_HASHVAL, md, &digest_len, 0)) { status = GetLastError(); MsgToEventLog(EVENTLOG_ERROR_TYPE, L"Error in md_final: status = %lu", status); } CryptDestroyHash(ctx->hash); CryptReleaseContext(ctx->prov, 0); return status; } /* Open specified http/https URL using ShellExecute. */ BOOL open_url(const wchar_t *url) { if (!url || !wcsbegins(url, L"http")) { return false; } HINSTANCE ret = ShellExecuteW(NULL, L"open", url, NULL, NULL, SW_SHOWNORMAL); if (ret <= (HINSTANCE) 32) { MsgToEventLog(EVENTLOG_ERROR_TYPE, L"launch_url: ShellExecute <%ls> returned error: %d", url, ret); return false; } return true; } extern options_t o; void ImportConfigFile(const TCHAR *source, bool prompt_user) { TCHAR fileName[MAX_PATH] = _T(""); TCHAR ext[MAX_PATH] = _T(""); _wsplitpath(source, NULL, NULL, fileName, ext); /* check if the source points to the config_dir */ if (wcsnicmp(source, o.global_config_dir, wcslen(o.global_config_dir)) == 0 || wcsnicmp(source, o.config_dir, wcslen(o.config_dir)) == 0) { ShowLocalizedMsg(IDS_ERR_IMPORT_SOURCE, source); return; } /* Ensure the source exists and is readable */ if (!CheckFileAccess(source, GENERIC_READ)) { ShowLocalizedMsg(IDS_ERR_IMPORT_ACCESS, source); return; } WCHAR destination[MAX_PATH+1]; bool no_overwrite = TRUE; /* profile name must be unique: check whether a config by same name exists */ connection_t *c = GetConnByName(fileName); if (c && wcsnicmp(c->config_dir, o.config_dir, wcslen(o.config_dir)) == 0) { /* Ask the user whether to replace the profile or not. */ if (ShowLocalizedMsgEx(MB_YESNO|MB_TOPMOST, o.hWnd, _T(PACKAGE_NAME), IDS_NFO_IMPORT_OVERWRITE, fileName) == IDNO) { return; } no_overwrite = FALSE; swprintf(destination, MAX_PATH, L"%ls\\%ls", c->config_dir, c->config_file); } else { if (prompt_user && ShowLocalizedMsgEx(MB_YESNO|MB_TOPMOST, o.hWnd, TEXT(PACKAGE_NAME), IDS_NFO_IMPORT_SOURCE, fileName) == IDNO) { return; } WCHAR dest_dir[MAX_PATH+1]; swprintf(dest_dir, MAX_PATH, L"%ls\\%ls", o.config_dir, fileName); dest_dir[MAX_PATH] = L'\0'; if (!EnsureDirExists(dest_dir)) { ShowLocalizedMsg(IDS_ERR_IMPORT_FAILED, dest_dir); return; } swprintf(destination, MAX_PATH, L"%ls\\%ls.%ls", dest_dir, fileName, o.ext_string); } destination[MAX_PATH] = L'\0'; if (!CopyFile(source, destination, no_overwrite)) { MsgToEventLog(EVENTLOG_ERROR_TYPE, L"Copy file <%ls> to <%ls> failed (error = %lu)", source, destination, GetLastError()); ShowLocalizedMsg(IDS_ERR_IMPORT_FAILED, destination); return; } ShowTrayBalloon(LoadLocalizedString(IDS_NFO_IMPORT_SUCCESS), fileName); /* destroy popup menus, based on existing num_configs, rescan file list and recreate menus */ RecreatePopupMenus(); } /* * Find a free port to bind and return it in addr.sin_port */ BOOL find_free_tcp_port(SOCKADDR_IN *addr) { BOOL ret = false; SOCKADDR_IN addr_bound; WSADATA wsaData; int len = sizeof(*addr); if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) { return ret; } u_short old_port = addr->sin_port; SOCKET sk = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (sk == INVALID_SOCKET) { MsgToEventLog(EVENTLOG_ERROR_TYPE, L"%hs: socket open failed", __func__); goto out; } while (bind(sk, (SOCKADDR *) addr, len)) { if (addr->sin_port == 0) { MsgToEventLog(EVENTLOG_ERROR_TYPE, L"%hs: bind to dynamic port failed", __func__); goto out; } addr->sin_port = 0; } if (getsockname(sk, (SOCKADDR *) &addr_bound, &len)) { MsgToEventLog(EVENTLOG_ERROR_TYPE, L"%hs: getsockname failed", __func__); goto out; } ret = true; out: if (sk != INVALID_SOCKET) { closesocket(sk); } addr->sin_port = ret ? addr_bound.sin_port : old_port; WSACleanup(); return ret; } /* Parse the management address and password * from a config file. Results are returned * in c->manage.skaddr and c->magage.password. * Returns false on parse error, or if address * not found. Password not found is not an error. */ BOOL ParseManagementAddress(connection_t *c) { BOOL ret = true; wchar_t *pw_file = NULL; wchar_t *workdir = c->config_dir; wchar_t config_path[MAX_PATH]; wchar_t pw_path[MAX_PATH] = L""; _sntprintf_0(config_path, L"%ls\\%ls", c->config_dir, c->config_file); config_entry_t *head = config_parse(config_path); config_entry_t *l = head; if (!head) { return false; } SOCKADDR_IN *addr = &c->manage.skaddr; addr->sin_port = 0; while (l) { if (l->ntokens >= 3 && !wcscmp(l->tokens[0], L"management")) { /* we require the address to be a numerical ipv4 address -- e.g., 127.0.0.1*/ if (InetPtonW(AF_INET, l->tokens[1], &addr->sin_addr) != 1) { config_list_free(head); return false; } addr->sin_port = htons(_wtoi(l->tokens[2])); pw_file = l->tokens[3]; /* may be null */ } else if (l->ntokens >= 2 && !wcscmp(l->tokens[0], L"cd")) { workdir = l->tokens[1]; } l = l->next; } ret = (addr->sin_port != 0); if (ret && pw_file) { if (PathIsRelativeW(pw_file)) { _sntprintf_0(pw_path, L"%ls\\%ls", workdir, pw_file); } else { wcsncpy_s(pw_path, MAX_PATH, pw_file, _TRUNCATE); } FILE *fp = _wfopen(pw_path, L"r"); if (!fp || !fgets(c->manage.password, sizeof(c->manage.password), fp)) { /* This may be normal as not all users may be given access to this secret */ ret = false; } StrTrimA(c->manage.password, "\n\r"); if (fp) { fclose(fp); } } config_list_free(head); PrintDebug(L"ParseManagementAddress: host = %hs port = %d passwd_file = %s", inet_ntoa(addr->sin_addr), ntohs(addr->sin_port), pw_path); return ret; } /* Write a message to the event log */ void MsgToEventLog(WORD type, wchar_t *format, ...) { const wchar_t *msg[2]; wchar_t buf[256]; int size = _countof(buf); if (!o.event_log) { o.event_log = RegisterEventSource(NULL, TEXT(PACKAGE_NAME)); if (!o.event_log) { return; } } va_list args; va_start(args, format); int nchar = vswprintf(buf, size-1, format, args); va_end(args); if (nchar == -1) { return; } buf[size - 1] = '\0'; msg[0] = TEXT(PACKAGE_NAME); msg[1] = buf; ReportEventW(o.event_log, type, 0, 0, NULL, 2, 0, msg, NULL); } /* * Get dpi of the system and set the scale factor. * The system dpi may be different from the per monitor dpi on * Win 8.1 later. We set dpi awareness to system-dpi level in the * manifest, and let Windows automatically re-scale windows * if/when dpi changes dynamically. */ void dpi_initialize(options_t *options) { UINT dpix = 0; HDC hdc = GetDC(NULL); if (hdc) { dpix = GetDeviceCaps(hdc, LOGPIXELSX); ReleaseDC(NULL, hdc); PrintDebug(L"System DPI: dpix = %u", dpix); } else { PrintDebug(L"GetDC failed, using default dpi = 96 (error = %lu)", GetLastError()); dpix = 96; } DpiSetScale(options, dpix); } #define PLAP_CLASSID "{4fbb8b67-cf02-4982-a7a8-3dd06a2c2ebd}" int GetPLAPRegistrationStatus(void) { int res = 0; HKEY regkey; wchar_t dllPath[MAX_PATH]; _sntprintf_0(dllPath, L"%ls%ls", o.install_path, L"bin\\libopenvpn_plap.dll"); if (!CheckFileAccess(dllPath, GENERIC_READ)) { res = -1; } else if (RegOpenKeyExW(HKEY_CLASSES_ROOT, L"CLSID\\"PLAP_CLASSID, 0, KEY_READ, ®key) == ERROR_SUCCESS) { res = 1; RegCloseKey(regkey); } return res; } DWORD SetPLAPRegistration(BOOL value) { DWORD res = -1; const wchar_t *cmd = L"C:\\windows\\system32\\reg.exe"; wchar_t params[MAX_PATH]; /* Run only if the state has changed */ int plap_status = GetPLAPRegistrationStatus(); if (plap_status > 0 && (BOOL) plap_status == value) { return 0; } if (value) { _sntprintf_0( params, L"import \"%ls%ls\"", o.install_path, L"bin\\openvpn-plap-install.reg"); } else { _sntprintf_0( params, L"import \"%ls%ls\"", o.install_path, L"bin\\openvpn-plap-uninstall.reg"); } res = RunAsAdmin(cmd, params); if (res != 0) { ShowLocalizedMsg(value ? IDS_ERR_PLAP_REG : IDS_ERR_PLAP_UNREG, res); } return res; } /* * Run a command as admin using shell execute and return the exit code. * Returns 0 on success or a non-zero exit code status of the command. * If the command fails to execute, the return value is (DWORD) -1. */ DWORD RunAsAdmin(const WCHAR *cmd, const WCHAR *params) { SHELLEXECUTEINFO shinfo; DWORD status = -1; CLEAR(shinfo); shinfo.cbSize = sizeof(shinfo); shinfo.fMask = SEE_MASK_NOCLOSEPROCESS; shinfo.hwnd = NULL; shinfo.lpVerb = L"runas"; shinfo.lpFile = cmd; shinfo.lpDirectory = NULL; shinfo.nShow = SW_HIDE; shinfo.lpParameters = params; if (ShellExecuteEx(&shinfo) && shinfo.hProcess) { WaitForSingleObject(shinfo.hProcess, INFINITE); GetExitCodeProcess(shinfo.hProcess, &status); CloseHandle(shinfo.hProcess); } return status; } /* Like sleep but service messages. If hdlg is not NULL * dialog messages for it are checked. Also services * MSG_FILTER hooks if caller wants further special processing. * Returns false on if WM_QUIT received else returns true (on timeout). */ bool OVPNMsgWait(DWORD timeout, HWND hdlg) { ULONGLONG now = GetTickCount64(); ULONGLONG end = now + timeout; while (end > now) { if (MsgWaitForMultipleObjectsEx(0, NULL, end - now, QS_ALLINPUT, MWMO_INPUTAVAILABLE) == WAIT_OBJECT_0) { MSG msg; while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { if (msg.message == WM_QUIT) { PostQuitMessage((int) msg.wParam); return false; } else if (!CallMsgFilter(&msg, MSGF_OVPN_WAIT) && (!hdlg || !IsDialogMessage(hdlg, &msg))) { TranslateMessage(&msg); DispatchMessage(&msg); } } } now = GetTickCount64(); } return true; } /* * Create a random password from the printable ASCII range */ bool GetRandomPassword(char *buf, size_t len) { HCRYPTPROV cp; BOOL retval = FALSE; unsigned i; if (!CryptAcquireContext(&cp, NULL, NULL, PROV_DSS, CRYPT_VERIFYCONTEXT)) { return FALSE; } if (!CryptGenRandom(cp, len, (PBYTE) buf)) { goto out; } /* Make sure all values are between 0x21 '!' and 0x7e '~' */ for (i = 0; i < len; ++i) { buf[i] = (buf[i] & 0x5d) + 0x21; } retval = TRUE; out: CryptReleaseContext(cp, 0); return retval; } /* Setup Password reveal * Inputs: edit handle to password edit control * btn handle to the control that toggles the reveal * wParam action being handled, or 0 for init */ void ResetPasswordReveal(HWND edit, HWND btn, WPARAM wParam) { if (!edit || !btn) { return; } if (o.disable_password_reveal) { ShowWindow(btn, SW_HIDE); return; } /* set the password field to be masked as a sane default */ SendMessage(edit, EM_SETPASSWORDCHAR, (WPARAM)'*', 0); SendMessage(btn, STM_SETIMAGE, (WPARAM) IMAGE_ICON, (LPARAM)LoadLocalizedSmallIcon(ID_ICO_EYE)); /* if password is not masked on init, disable reveal "button" */ if (wParam == 0 && SendMessage(edit, EM_GETPASSWORDCHAR, 0, 0) == 0) { ShowWindow(btn, SW_HIDE); } /* on losing focus disable password reveal button */ else if (HIWORD(wParam) == EN_KILLFOCUS) { ShowWindow(btn, SW_HIDE); } /* if/when password is cleared enable/re-enable reveal button */ else if (GetWindowTextLength(edit) == 0) { ShowWindow(btn, SW_SHOW); } } /* Toggle masking of text in password field * Inputs: edit handle to password edit control * btn handle to the control that toggles the reveal * wParam action being handled */ void ChangePasswordVisibility(HWND edit, HWND btn, WPARAM wParam) { if (!edit || !btn) { return; } if (HIWORD(wParam) == STN_CLICKED) { if (SendMessage(edit, EM_GETPASSWORDCHAR, 0, 0) == 0) /* currently visible */ { SendMessage(edit, EM_SETPASSWORDCHAR, (WPARAM)'*', 0); SendMessage(btn, STM_SETIMAGE, (WPARAM) IMAGE_ICON, (LPARAM)LoadLocalizedSmallIcon(ID_ICO_EYE)); } else { SendMessage(edit, EM_SETPASSWORDCHAR, 0, 0); SendMessage(btn, STM_SETIMAGE, (WPARAM) IMAGE_ICON, (LPARAM)LoadLocalizedSmallIcon(ID_ICO_EYESTROKE)); } InvalidateRect(edit, NULL, TRUE); /* without this the control doesn't seem to get redrawn promptly */ } }