253 lines
9.1 KiB
Plaintext
253 lines
9.1 KiB
Plaintext
// Copyright (c) 2016 Ryan Prichard
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
|
|
#include "WindowsVersion.h"
|
|
|
|
#include <windows.h>
|
|
#include <stdint.h>
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
#include <tuple>
|
|
|
|
#include "DebugClient.h"
|
|
#include "OsModule.h"
|
|
#include "StringBuilder.h"
|
|
#include "StringUtil.h"
|
|
#include "WinptyAssert.h"
|
|
#include "WinptyException.h"
|
|
|
|
namespace {
|
|
|
|
typedef std::tuple<DWORD, DWORD> Version;
|
|
|
|
// This function can only return a version up to 6.2 unless the executable is
|
|
// manifested for a newer version of Windows. See the MSDN documentation for
|
|
// GetVersionEx.
|
|
OSVERSIONINFOEX getWindowsVersionInfo() {
|
|
// Allow use of deprecated functions (i.e. GetVersionEx). We need to use
|
|
// GetVersionEx for the old MinGW toolchain and with MSVC when it targets XP.
|
|
// Having two code paths makes code harder to test, and it's not obvious how
|
|
// to detect the presence of a new enough SDK. (Including ntverp.h and
|
|
// examining VER_PRODUCTBUILD apparently works, but even then, MinGW-w64 and
|
|
// MSVC seem to use different version numbers.)
|
|
#ifdef _MSC_VER
|
|
#pragma warning(push)
|
|
#pragma warning(disable:4996)
|
|
#endif
|
|
OSVERSIONINFOEX info = {};
|
|
info.dwOSVersionInfoSize = sizeof(info);
|
|
const auto success = GetVersionEx(reinterpret_cast<OSVERSIONINFO*>(&info));
|
|
ASSERT(success && "GetVersionEx failed");
|
|
return info;
|
|
#ifdef _MSC_VER
|
|
#pragma warning(pop)
|
|
#endif
|
|
}
|
|
|
|
Version getWindowsVersion() {
|
|
const auto info = getWindowsVersionInfo();
|
|
return Version(info.dwMajorVersion, info.dwMinorVersion);
|
|
}
|
|
|
|
struct ModuleNotFound : WinptyException {
|
|
virtual const wchar_t *what() const WINPTY_NOEXCEPT override {
|
|
return L"ModuleNotFound";
|
|
}
|
|
};
|
|
|
|
// Throws WinptyException on error.
|
|
std::wstring getSystemDirectory() {
|
|
wchar_t systemDirectory[MAX_PATH];
|
|
const UINT size = GetSystemDirectoryW(systemDirectory, MAX_PATH);
|
|
if (size == 0) {
|
|
throwWindowsError(L"GetSystemDirectory failed");
|
|
} else if (size >= MAX_PATH) {
|
|
throwWinptyException(
|
|
L"GetSystemDirectory: path is longer than MAX_PATH");
|
|
}
|
|
return systemDirectory;
|
|
}
|
|
|
|
#define GET_VERSION_DLL_API(name) \
|
|
const auto p ## name = \
|
|
reinterpret_cast<decltype(name)*>( \
|
|
versionDll.proc(#name)); \
|
|
if (p ## name == nullptr) { \
|
|
throwWinptyException(L ## #name L" is missing"); \
|
|
}
|
|
|
|
// Throws WinptyException on error.
|
|
VS_FIXEDFILEINFO getFixedFileInfo(const std::wstring &path) {
|
|
// version.dll is not a conventional KnownDll, so if we link to it, there's
|
|
// a danger of accidentally loading a malicious DLL. In a more typical
|
|
// application, perhaps we'd guard against this security issue by
|
|
// controlling which directories this code runs in (e.g. *not* the
|
|
// "Downloads" directory), but that's harder for the winpty library.
|
|
OsModule versionDll(
|
|
(getSystemDirectory() + L"\\version.dll").c_str(),
|
|
OsModule::LoadErrorBehavior::Throw);
|
|
GET_VERSION_DLL_API(GetFileVersionInfoSizeW);
|
|
GET_VERSION_DLL_API(GetFileVersionInfoW);
|
|
GET_VERSION_DLL_API(VerQueryValueW);
|
|
DWORD size = pGetFileVersionInfoSizeW(path.c_str(), nullptr);
|
|
if (!size) {
|
|
// I see ERROR_FILE_NOT_FOUND on Win7 and
|
|
// ERROR_RESOURCE_DATA_NOT_FOUND on WinXP.
|
|
if (GetLastError() == ERROR_FILE_NOT_FOUND ||
|
|
GetLastError() == ERROR_RESOURCE_DATA_NOT_FOUND) {
|
|
throw ModuleNotFound();
|
|
} else {
|
|
throwWindowsError(
|
|
(L"GetFileVersionInfoSizeW failed on " + path).c_str());
|
|
}
|
|
}
|
|
std::unique_ptr<char[]> versionBuffer(new char[size]);
|
|
if (!pGetFileVersionInfoW(path.c_str(), 0, size, versionBuffer.get())) {
|
|
throwWindowsError((L"GetFileVersionInfoW failed on " + path).c_str());
|
|
}
|
|
VS_FIXEDFILEINFO *versionInfo = nullptr;
|
|
UINT versionInfoSize = 0;
|
|
if (!pVerQueryValueW(
|
|
versionBuffer.get(), L"\\",
|
|
reinterpret_cast<void**>(&versionInfo), &versionInfoSize) ||
|
|
versionInfo == nullptr ||
|
|
versionInfoSize != sizeof(VS_FIXEDFILEINFO) ||
|
|
versionInfo->dwSignature != 0xFEEF04BD) {
|
|
throwWinptyException((L"VerQueryValueW failed on " + path).c_str());
|
|
}
|
|
return *versionInfo;
|
|
}
|
|
|
|
uint64_t productVersionFromInfo(const VS_FIXEDFILEINFO &info) {
|
|
return (static_cast<uint64_t>(info.dwProductVersionMS) << 32) |
|
|
(static_cast<uint64_t>(info.dwProductVersionLS));
|
|
}
|
|
|
|
uint64_t fileVersionFromInfo(const VS_FIXEDFILEINFO &info) {
|
|
return (static_cast<uint64_t>(info.dwFileVersionMS) << 32) |
|
|
(static_cast<uint64_t>(info.dwFileVersionLS));
|
|
}
|
|
|
|
std::string versionToString(uint64_t version) {
|
|
StringBuilder b(32);
|
|
b << ((uint16_t)(version >> 48));
|
|
b << '.';
|
|
b << ((uint16_t)(version >> 32));
|
|
b << '.';
|
|
b << ((uint16_t)(version >> 16));
|
|
b << '.';
|
|
b << ((uint16_t)(version >> 0));
|
|
return b.str_moved();
|
|
}
|
|
|
|
} // anonymous namespace
|
|
|
|
// Returns true for Windows Vista (or Windows Server 2008) or newer.
|
|
bool isAtLeastWindowsVista() {
|
|
return getWindowsVersion() >= Version(6, 0);
|
|
}
|
|
|
|
// Returns true for Windows 7 (or Windows Server 2008 R2) or newer.
|
|
bool isAtLeastWindows7() {
|
|
return getWindowsVersion() >= Version(6, 1);
|
|
}
|
|
|
|
// Returns true for Windows 8 (or Windows Server 2012) or newer.
|
|
bool isAtLeastWindows8() {
|
|
return getWindowsVersion() >= Version(6, 2);
|
|
}
|
|
|
|
#define WINPTY_IA32 1
|
|
#define WINPTY_X64 2
|
|
|
|
#if defined(_M_IX86) || defined(__i386__)
|
|
#define WINPTY_ARCH WINPTY_IA32
|
|
#elif defined(_M_X64) || defined(__x86_64__)
|
|
#define WINPTY_ARCH WINPTY_X64
|
|
#endif
|
|
|
|
typedef BOOL WINAPI IsWow64Process_t(HANDLE hProcess, PBOOL Wow64Process);
|
|
|
|
void dumpWindowsVersion() {
|
|
if (!isTracingEnabled()) {
|
|
return;
|
|
}
|
|
const auto info = getWindowsVersionInfo();
|
|
StringBuilder b;
|
|
b << info.dwMajorVersion << '.' << info.dwMinorVersion
|
|
<< '.' << info.dwBuildNumber << ' '
|
|
<< "SP" << info.wServicePackMajor << '.' << info.wServicePackMinor
|
|
<< ' ';
|
|
switch (info.wProductType) {
|
|
case VER_NT_WORKSTATION: b << "Client"; break;
|
|
case VER_NT_DOMAIN_CONTROLLER: b << "DomainController"; break;
|
|
case VER_NT_SERVER: b << "Server"; break;
|
|
default:
|
|
b << "product=" << info.wProductType; break;
|
|
}
|
|
b << ' ';
|
|
#if WINPTY_ARCH == WINPTY_IA32
|
|
b << "IA32";
|
|
OsModule kernel32(L"kernel32.dll");
|
|
IsWow64Process_t *pIsWow64Process =
|
|
reinterpret_cast<IsWow64Process_t*>(
|
|
kernel32.proc("IsWow64Process"));
|
|
if (pIsWow64Process != nullptr) {
|
|
BOOL result = false;
|
|
const BOOL success = pIsWow64Process(GetCurrentProcess(), &result);
|
|
if (!success) {
|
|
b << " WOW64:error";
|
|
} else if (success && result) {
|
|
b << " WOW64";
|
|
}
|
|
} else {
|
|
b << " WOW64:missingapi";
|
|
}
|
|
#elif WINPTY_ARCH == WINPTY_X64
|
|
b << "X64";
|
|
#endif
|
|
const auto dllVersion = [](const wchar_t *dllPath) -> std::string {
|
|
try {
|
|
const auto info = getFixedFileInfo(dllPath);
|
|
StringBuilder fb(64);
|
|
fb << utf8FromWide(dllPath) << ':';
|
|
fb << "F:" << versionToString(fileVersionFromInfo(info)) << '/'
|
|
<< "P:" << versionToString(productVersionFromInfo(info));
|
|
return fb.str_moved();
|
|
} catch (const ModuleNotFound&) {
|
|
return utf8FromWide(dllPath) + ":none";
|
|
} catch (const WinptyException &e) {
|
|
trace("Error getting %s version: %s",
|
|
utf8FromWide(dllPath).c_str(), utf8FromWide(e.what()).c_str());
|
|
return utf8FromWide(dllPath) + ":error";
|
|
}
|
|
};
|
|
b << ' ' << dllVersion(L"kernel32.dll");
|
|
// ConEmu provides a DLL that hooks many Windows APIs, especially console
|
|
// APIs. Its existence and version number could be useful in debugging.
|
|
#if WINPTY_ARCH == WINPTY_IA32
|
|
b << ' ' << dllVersion(L"ConEmuHk.dll");
|
|
#elif WINPTY_ARCH == WINPTY_X64
|
|
b << ' ' << dllVersion(L"ConEmuHk64.dll");
|
|
#endif
|
|
trace("Windows version: %s", b.c_str());
|
|
}
|