// Get whether the current OS is supported by SeLow
bool SuIsSupportedOs(bool on_install)
{
if (MsRegReadIntEx2(REG_LOCAL_MACHINE, SL_REG_KEY_NAME, "EnableSeLow", false, true) != 0)
{
// Force enable
return true;
}
if (MsRegReadIntEx2(REG_LOCAL_MACHINE, SL_REG_KEY_NAME, "DisableSeLow", false, true) != 0)
{
// Force disable
return false;
}
if (MsIsWindows10())
{
// Windows 10 or later are always supported.
return true;
}
if (on_install)
{
// If Microsoft Routing and Remote Access service is running,
// then return false.
if (MsIsServiceRunning("RemoteAccess"))
{
return false;
}
}
// If the Su driver is currently running,
// then return true.
if (MsIsServiceRunning(SL_PROTOCOL_NAME))
{
return true;
}
// Currently Windows 8.1 or later are supported
if (MsIsWindows81() == false)
{
return false;
}
if (on_install == false)
{
// If Microsoft Routing and Remote Access service is running,
// then return false.
if (MsIsServiceRunning("RemoteAccess"))
{
return false;
}
}
return true;
}
// Get the current installation state for the given architecture
void ViLoadCurrentInstalledStatusForArch(VI_SETTING_ARCH *a)
{
char tmp[MAX_SIZE];
UINT build;
wchar_t *dir;
// Validate arguments
if (a == NULL)
{
return;
}
if (a->Supported == false)
{
// Unsupported
return;
}
// Read from the registry
Format(tmp, sizeof(tmp), "%s\\%s", SW_REG_KEY, "vpnclient");
build = MsRegReadIntEx2(REG_LOCAL_MACHINE, tmp, "InstalledBuild", false, true);
dir = MsRegReadStrEx2W(REG_LOCAL_MACHINE, tmp, "InstalledDir", false, true);
if (build == 0 || UniIsEmptyStr(dir))
{
// Not installed
a->CurrentInstalled = false;
}
else
{
// Installed
a->CurrentInstalled = true;
a->CurrentInstalledBuild = build;
UniStrCpy(a->CurrentInstalledPathW, sizeof(a->CurrentInstalledPathW), dir);
}
Free(dir);
}
bool SuInstallDriverInner(bool force)
{
wchar_t sys_fullpath[MAX_PATH];
UINT current_sl_ver = 0;
bool ret = false;
wchar_t src_cat[MAX_PATH];
wchar_t src_inf[MAX_PATH];
wchar_t src_sys[MAX_PATH];
wchar_t dst_cat[MAX_PATH];
wchar_t dst_inf[MAX_PATH];
wchar_t dst_sys[MAX_PATH];
wchar_t tmp_dir[MAX_PATH];
char *cpu_type = MsIsX64() ? "x64" : "x86";
if (SuIsSupportedOs(true) == false)
{
// Unsupported OS
return false;
}
CombinePathW(tmp_dir, sizeof(tmp_dir), MsGetWindowsDirW(), L"Temp");
MakeDirExW(tmp_dir);
UniStrCat(tmp_dir, sizeof(tmp_dir), L"\\selowtmp");
MakeDirExW(tmp_dir);
// Confirm whether the driver is currently installed
CombinePathW(sys_fullpath, sizeof(sys_fullpath), MsGetSystem32DirW(), L"drivers\\SeLow_%S.sys");
UniFormat(sys_fullpath, sizeof(sys_fullpath), sys_fullpath, cpu_type);
if (IsFileExistsW(sys_fullpath))
{
char *path;
// Read the current version from the registry
current_sl_ver = MsRegReadIntEx2(REG_LOCAL_MACHINE, SL_REG_KEY_NAME,
(MsIsWindows10() ? SL_REG_VER_VALUE_WIN10 : SL_REG_VER_VALUE),
false, true);
path = MsRegReadStrEx2(REG_LOCAL_MACHINE, SL_REG_KEY_NAME, "ImagePath", false, true);
if (IsEmptyStr(path) || IsFileExists(path) == false || MsIsServiceInstalled(SL_PROTOCOL_NAME) == false)
{
current_sl_ver = 0;
}
Free(path);
}
if (force == false && current_sl_ver >= SL_VER)
{
// Newer version has already been installed
Debug("Newer SeLow is Installed. %u >= %u\n", current_sl_ver, SL_VER);
return true;
}
// Copy necessary files to a temporary directory
UniFormat(src_sys, sizeof(src_sys), L"|DriverPackages\\%S\\%S\\SeLow_%S.sys",
(MsIsWindows10() ? "SeLow_Win10" : "SeLow_Win8"),
cpu_type, cpu_type);
if (MsIsWindows8() == false)
{
// Windows Vista and Windows 7 uses SHA-1 catalog files
UniFormat(src_cat, sizeof(src_cat), L"|DriverPackages\\SeLow_Win8\\%S\\inf.cat", cpu_type);
}
else
{
// Windows 8 or above uses SHA-256 catalog files
UniFormat(src_cat, sizeof(src_cat), L"|DriverPackages\\SeLow_Win8\\%S\\inf2.cat", cpu_type);
if (MsIsWindows10())
{
// Windows 10 uses WHQL catalog files
UniFormat(src_cat, sizeof(src_cat), L"|DriverPackages\\SeLow_Win10\\%S\\SeLow_Win10_%S.cat", cpu_type, cpu_type);
}
}
UniFormat(src_inf, sizeof(src_inf), L"|DriverPackages\\%S\\%S\\SeLow_%S.inf",
(MsIsWindows10() ? "SeLow_Win10" : "SeLow_Win8"),
cpu_type, cpu_type);
UniFormat(dst_sys, sizeof(dst_cat), L"%s\\SeLow_%S.sys", tmp_dir, cpu_type);
UniFormat(dst_cat, sizeof(dst_cat), L"%s\\SeLow_%S_%S.cat", tmp_dir,
(MsIsWindows10() ? "Win10" : "Win8"),
cpu_type);
UniFormat(dst_inf, sizeof(dst_inf), L"%s\\SeLow_%S.inf", tmp_dir, cpu_type);
if (FileCopyW(src_sys, dst_sys) &&
FileCopyW(src_cat, dst_cat) &&
FileCopyW(src_inf, dst_inf))
{
NO_WARNING *nw;
nw = MsInitNoWarningEx(SL_USER_AUTO_PUSH_TIMER);
if (MsIsWindows10())
{
if (MsIsServiceInstalled(SL_PROTOCOL_NAME) == false && MsIsServiceRunning(SL_PROTOCOL_NAME) == false)
{
// On Windows 10, if there are no SwLow service installed, then uinstall the protocol driver first.
// TODO: currently do nothing. On some versions of Windows 10 beta builds it is necessary to do something...
}
}
if (MsIsWindows10())
{
// Delete garbage INFs
SuDeleteGarbageInfs();
}
// Call the installer
if (InstallNdisProtocolDriver(dst_inf, L"SeLow", SL_USER_INSTALL_LOCK_TIMEOUT) == false)
{
Debug("InstallNdisProtocolDriver Error.\n");
}
else
{
Debug("InstallNdisProtocolDriver Ok.\n");
// Copy manually because there are cases where .sys file is not copied successfully for some reason
FileCopyW(src_sys, sys_fullpath);
ret = true;
// Write the version number into the registry
MsRegWriteIntEx2(REG_LOCAL_MACHINE, SL_REG_KEY_NAME,
(MsIsWindows10() ? SL_REG_VER_VALUE_WIN10 : SL_REG_VER_VALUE),
SL_VER, false, true);
// Set to automatic startup
MsRegWriteIntEx2(REG_LOCAL_MACHINE, SL_REG_KEY_NAME, "Start", SERVICE_SYSTEM_START, false, true);
}
MsFreeNoWarning(nw);
}
else
{
Debug("Fail Copying Files.\n");
}
if (ret)
{
// If the service is installed this time, start and wait until the enumeration is completed
SuFree(SuInitEx(180 * 1000));
}
return ret;
}
