├── ExeIntegrityBypassAgainstRGL
    ├── framework.h
    ├── pch.cpp
    ├── pch.h
    ├── Logger.h
    ├── ExeIntegrityBypassAgainstRGL.vcxproj.filters
    ├── Logger.cpp
    ├── dllmain.cpp
    └── ExeIntegrityBypassAgainstRGL.vcxproj
├── .gitignore
├── README.md
├── LICENSE
└── ExeIntegrityBypassAgainstRGL.sln


/ExeIntegrityBypassAgainstRGL/framework.h:
--------------------------------------------------------------------------------
1 | #pragma once
2 | 
3 | #define WIN32_LEAN_AND_MEAN             // Exclude rarely-used stuff from Windows headers
4 | // Windows Header Files
5 | #include <windows.h>
6 | #include <Psapi.h>
7 | 


--------------------------------------------------------------------------------
/ExeIntegrityBypassAgainstRGL/pch.cpp:
--------------------------------------------------------------------------------
1 | // pch.cpp: source file corresponding to the pre-compiled header
2 | 
3 | #include "pch.h"
4 | 
5 | // When you are using pre-compiled headers, this source file is necessary for compilation to succeed.
6 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Build results
 2 | [Bb]in/
 3 | [Oo]bj/
 4 | [Dd]ebug/
 5 | [Ll]og/
 6 | [Tt]mp/
 7 | /x64/
 8 | 
 9 | # Visual Studio cache files
10 | ipch/
11 | *.aps
12 | *.cachefile
13 | *.opendb
14 | *.opensdf
15 | *.user
16 | *.sdf
17 | *.suo
18 | *.db
19 | .vs/
20 | 
21 | # Temporary OS files
22 | .DS_Store
23 | Thumbs.db
24 | 
25 | # NuGet stuff
26 | [Pp]ackages/
27 | packages.config
28 | 
29 | *.log
30 | *.exe
31 | 
32 | # Temp
33 | *.TMP
34 | doc/changelog.pdf
35 | Gears/GitInfo.h
36 | 


--------------------------------------------------------------------------------
/ExeIntegrityBypassAgainstRGL/pch.h:
--------------------------------------------------------------------------------
 1 | // pch.h: This is a precompiled header file.
 2 | // Files listed below are compiled only once, improving build performance for future builds.
 3 | // This also affects IntelliSense performance, including code completion and many code browsing features.
 4 | // However, files listed here are ALL re-compiled if any one of them is updated between builds.
 5 | // Do not add files here that you will be updating frequently as this negates the performance advantage.
 6 | 
 7 | #ifndef PCH_H
 8 | #define PCH_H
 9 | 
10 | // add headers that you want to pre-compile here
11 | #include "framework.h"
12 | 
13 | #endif //PCH_H
14 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Exe Integrity Bypass Against RGL
2 | 
3 | This mod disables the integrity check (version check) against the exe of GTA V, where the game will test if it is the latest version as of the game launch using the function that calls `CryptAcquireContextA`, `CryptMsgGetParam`, and `CryptQueryObject`. Looks like Rockstar started testing even in Steam and EGS versions starting from April 4th, 2023 UTC at the latest.
4 | 
5 | In short words, this mod just makes GTA5.exe not listen to the result of version check.
6 | 
7 | ### License
8 | Exe Integrity Bypass Against RGL is licensed under the BSD Zero Clause License. Too few pieces of materials to be worth keeping secret.
9 | 


--------------------------------------------------------------------------------
/ExeIntegrityBypassAgainstRGL/Logger.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <string>
 3 | #include <fstream>
 4 | 
 5 | enum class LogType : int {
 6 |     Info,
 7 |     // the same type as the ERROR info GTAVLauncherBypass by alloc8or can write
 8 |     Error,
 9 | };
10 | 
11 | class Logger
12 | {
13 | private:
14 |     std::ofstream log_file_;
15 | 
16 | public:
17 |     Logger() {
18 |     };
19 |     Logger(const std::string& file_name) {
20 |         log_file_ = std::ofstream(file_name);
21 |     };
22 |     void AddLine(const LogType type, const std::string& message);
23 | 
24 |     explicit operator bool() const
25 |     {
26 |         return static_cast<bool>(log_file_);
27 |     }
28 | };


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (C) 2023 by Kazuma Takemura <kagikn.3939@gmail.com>
 2 | 
 3 | Permission to use, copy, modify, and/or distribute this software for
 4 | any purpose with or without fee is hereby granted.
 5 | 
 6 | THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL
 7 | WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
 8 | OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE
 9 | FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY
10 | DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
11 | AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
12 | OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.


--------------------------------------------------------------------------------
/ExeIntegrityBypassAgainstRGL.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 17
 4 | VisualStudioVersion = 17.4.33213.308
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ExeIntegrityBypassAgainstRGL", "ExeIntegrityBypassAgainstRGL\ExeIntegrityBypassAgainstRGL.vcxproj", "{3350DCE0-9D8A-4345-853F-8B9C658AAA45}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|x64 = Debug|x64
11 | 		Release|x64 = Release|x64
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{3350DCE0-9D8A-4345-853F-8B9C658AAA45}.Debug|x64.ActiveCfg = Debug|x64
15 | 		{3350DCE0-9D8A-4345-853F-8B9C658AAA45}.Debug|x64.Build.0 = Debug|x64
16 | 		{3350DCE0-9D8A-4345-853F-8B9C658AAA45}.Release|x64.ActiveCfg = Release|x64
17 | 		{3350DCE0-9D8A-4345-853F-8B9C658AAA45}.Release|x64.Build.0 = Release|x64
18 | 	EndGlobalSection
19 | 	GlobalSection(SolutionProperties) = preSolution
20 | 		HideSolutionNode = FALSE
21 | 	EndGlobalSection
22 | 	GlobalSection(ExtensibilityGlobals) = postSolution
23 | 		SolutionGuid = {31CBD60E-DD3E-4095-A879-3027D6E8935F}
24 | 	EndGlobalSection
25 | EndGlobal
26 | 


--------------------------------------------------------------------------------
/ExeIntegrityBypassAgainstRGL/ExeIntegrityBypassAgainstRGL.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="Source Files">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="Header Files">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="Resource Files">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <ClInclude Include="framework.h">
19 |       <Filter>Header Files</Filter>
20 |     </ClInclude>
21 |     <ClInclude Include="pch.h">
22 |       <Filter>Header Files</Filter>
23 |     </ClInclude>
24 |     <ClInclude Include="Logger.h">
25 |       <Filter>Header Files</Filter>
26 |     </ClInclude>
27 |   </ItemGroup>
28 |   <ItemGroup>
29 |     <ClCompile Include="dllmain.cpp">
30 |       <Filter>Source Files</Filter>
31 |     </ClCompile>
32 |     <ClCompile Include="pch.cpp">
33 |       <Filter>Source Files</Filter>
34 |     </ClCompile>
35 |     <ClCompile Include="Logger.cpp">
36 |       <Filter>Source Files</Filter>
37 |     </ClCompile>
38 |   </ItemGroup>
39 | </Project>


--------------------------------------------------------------------------------
/ExeIntegrityBypassAgainstRGL/Logger.cpp:
--------------------------------------------------------------------------------
 1 | #include "pch.h"
 2 | #include "Logger.h"
 3 | #include <format>
 4 | #include <chrono>
 5 | 
 6 | std::string CreateStringWithBracket(const std::string& str) {
 7 |     std::string str_with_bracket = std::string(str);
 8 |     str_with_bracket.insert(0, "[");
 9 |     str_with_bracket += "]";
10 | 
11 |     return str_with_bracket;
12 | }
13 | 
14 | // Using std::chrono stuff will result in a large dll
15 | std::string CreateIso8061LocalTimeStringNoTSeparator(const std::time_t unixTime) {
16 |     __time64_t time;
17 |     _time64(&time);
18 | 
19 |     struct tm local_time;
20 |     _localtime64_s(&local_time, &time);
21 | 
22 |     constexpr size_t BUF_SIZE_TIME_STR = 0x50u;
23 |     std::string temp_buf;
24 |     temp_buf.resize(BUF_SIZE_TIME_STR);
25 | 
26 |     const size_t written_char_count = strftime(temp_buf.data(), BUF_SIZE_TIME_STR, "%Y-%m-%d %H:%M:%S", &local_time);
27 |     temp_buf.resize(written_char_count);
28 | 
29 |     return temp_buf;
30 | }
31 | 
32 | std::string GetLogTypeEnumString(LogType type) {
33 |     switch (type) {
34 |         case LogType::Info:
35 |             return std::string("INFO");
36 |         case LogType::Error:
37 |             return std::string("ERROR");
38 |         default: return std::string("UNKNOWN");
39 |     }
40 | }
41 | 
42 | void Logger::AddLine(const LogType type, const std::string& message) {
43 |     std::time_t unixTimeScanStarted = std::time(nullptr);
44 |     const auto formatted_time_str = CreateIso8061LocalTimeStringNoTSeparator(unixTimeScanStarted);
45 |     log_file_ << "[" << formatted_time_str << "]" << " ";
46 | 
47 |     log_file_ << "[" << GetLogTypeEnumString(type) << "]" << " ";
48 |     
49 |     log_file_ << message << std::endl;
50 | }


--------------------------------------------------------------------------------
/ExeIntegrityBypassAgainstRGL/dllmain.cpp:
--------------------------------------------------------------------------------
  1 | #include "pch.h"
  2 | #include "Logger.h"
  3 | #include <TlHelp32.h>
  4 | #include <vector>
  5 | #include <sstream>
  6 | #include <fstream>
  7 | #include <string>
  8 | 
  9 | namespace {
 10 |     std::vector<std::string> split(std::string str, std::string separator) {
 11 |         if (separator == "") return { str };
 12 |         std::vector<std::string> result;
 13 |         std::string tstr = str + separator;
 14 |         size_t l = tstr.length(), sl = separator.length();
 15 |         std::string::size_type pos = 0, prev = 0;
 16 | 
 17 |         for (; pos < l && (pos = tstr.find(separator, pos)) != std::string::npos; prev = (pos += sl)) {
 18 |             result.emplace_back(tstr, prev, pos - prev);
 19 |         }
 20 |         return result;
 21 |     }
 22 | }
 23 | 
 24 | uintptr_t FindPattern(std::string patternStr) {
 25 |     auto space_separator = std::string(" ");
 26 |     std::vector<std::string> byte_str = split(patternStr, space_separator);
 27 | 
 28 |     MODULEINFO module_info{};
 29 |     const DWORD module_info_size = static_cast<DWORD>(sizeof(MODULEINFO));
 30 |     GetModuleInformation(GetCurrentProcess(), GetModuleHandle(nullptr), &module_info, module_info_size);
 31 | 
 32 |     auto* start_offset = static_cast<uint8_t*>(module_info.lpBaseOfDll);
 33 |     const auto size = static_cast<uintptr_t>(module_info.SizeOfImage);
 34 | 
 35 |     uintptr_t pos = 0;
 36 |     const uintptr_t search_len = byte_str.size();
 37 | 
 38 |     for (auto* ret_address = start_offset; ret_address < start_offset + size; ret_address++) {
 39 |         if (byte_str[pos] == "??" || byte_str[pos] == "?" ||
 40 |             *ret_address == static_cast<uint8_t>(std::strtoul(byte_str[pos].c_str(), nullptr, 16))) {
 41 |             if (pos + 1 == byte_str.size())
 42 |                 return (reinterpret_cast<uintptr_t>(ret_address) - search_len + 1);
 43 |             pos++;
 44 |         }
 45 |         else {
 46 |             pos = 0;
 47 |         }
 48 |     }
 49 |     return 0;
 50 | }
 51 | 
 52 | BOOL SuspendSpecifiedThread(DWORD thread_id, bool suspend)
 53 | {
 54 |     HANDLE snHandle = nullptr;
 55 |     THREADENTRY32 te32 = { 0 };
 56 | 
 57 |     BOOL succeeded = false;
 58 | 
 59 |     DWORD current_process_id = GetCurrentProcessId();
 60 | 
 61 |     snHandle = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
 62 |     if (snHandle == INVALID_HANDLE_VALUE) return (false);
 63 | 
 64 |     te32.dwSize = sizeof(THREADENTRY32);
 65 |     if (Thread32First(snHandle, &te32))
 66 |     {
 67 |         do
 68 |         {
 69 |             if (te32.th32OwnerProcessID == current_process_id && te32.th32ThreadID == thread_id)
 70 |             {
 71 |                 HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE, te32.th32ThreadID);
 72 |                 if (hThread == NULL) {
 73 |                     continue;
 74 |                 } else if (!suspend) {
 75 |                     succeeded = (bool)ResumeThread(hThread);
 76 |                 } else {
 77 |                     succeeded = (bool)SuspendThread(hThread);
 78 |                 }
 79 | 
 80 |                 CloseHandle(hThread);
 81 |             }
 82 |         } while (Thread32Next(snHandle, &te32));
 83 |     }
 84 |     CloseHandle(snHandle);
 85 | 
 86 |     return succeeded;
 87 | }
 88 | 
 89 | Logger logger;
 90 | DWORD main_thread_id;
 91 | HMODULE this_module;
 92 | 
 93 | void PatchExeIntegrityCheck() {
 94 |     // Wait for a second, main thread
 95 |     SuspendSpecifiedThread(main_thread_id, true);
 96 | 
 97 |     // The function where this integrity check is done should be already decrypted when this asi is attached (but encrypted when the exe is not started at all)
 98 |     // Should patch before you can see the game window
 99 |     // This memory pattern is tested in b2060, b2372, b2699, and b2845
100 |     const std::string pattern_for_exe_integrity_check = "84 C0 75 1B 39 ? 60 01 00 00 0F 85";
101 |     const uintptr_t addr = FindPattern(pattern_for_exe_integrity_check);
102 | 
103 |     if (addr) {
104 |         // Let's fuck the integrity check by making the exe not listen to the query result against the function that calls
105 |         // CryptAcquireContextA, CryptMsgGetParam, and CryptQueryObject against socialclub.dll
106 |         void* write_addr = reinterpret_cast<void*>(addr + 2);
107 |         const uint8_t instruction_to_write[1] = { 0xEB }; // patch jnz with jmp instruction
108 | 
109 |         DWORD old_protect = 0;
110 |         VirtualProtect(write_addr, 1u, PAGE_EXECUTE_READWRITE, &old_protect);
111 |         memcpy(write_addr, instruction_to_write, 1);
112 |         VirtualProtect(write_addr, 1u, old_protect, &old_protect);
113 | 
114 |         if (logger) {
115 |             logger.AddLine(LogType::Info, "Done!");
116 |         }
117 |         SuspendSpecifiedThread(main_thread_id, false);
118 |         FreeLibraryAndExitThread(this_module, 0);
119 |         return;
120 |     }
121 | 
122 |     if (logger) {
123 |         logger.AddLine(LogType::Error, "Failed to patch the integrity check against exe.");
124 |     }   
125 |     SuspendSpecifiedThread(main_thread_id, false);
126 |     FreeLibraryAndExitThread(this_module, 0);
127 | }
128 | 
129 | void Main(HMODULE hModule) {
130 |     logger = Logger("ExeIntegrityBypassAgainstRGL.log");
131 | 
132 |     if (logger) {
133 |         logger.AddLine(LogType::Info, "Started to patch the integrity check against exe...");
134 |     }
135 |  
136 |     this_module = hModule;
137 |     main_thread_id = GetCurrentThreadId();
138 |     auto thread_handle = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)PatchExeIntegrityCheck, hModule, NULL, NULL);
139 |     if (thread_handle == nullptr) {
140 |         if (logger) {
141 |             logger.AddLine(LogType::Error, "Thread creation failed, terminating...");
142 |             FreeLibraryAndExitThread(hModule, 0);
143 |         }
144 |     } else {
145 |         CloseHandle(thread_handle);
146 |     }
147 | }
148 | 
149 | BOOL APIENTRY DllMain( HMODULE hModule,
150 |                        DWORD  ul_reason_for_call,
151 |                        LPVOID lpReserved
152 |                      )
153 | {
154 |     switch (ul_reason_for_call)
155 |     {
156 |     case DLL_PROCESS_ATTACH:
157 |         // Have to patch the assembly with another thread to avoid the "failed to load" error for taking too long time to pass through DllMain
158 |         Main(hModule);
159 |         break;
160 |     case DLL_THREAD_ATTACH:
161 |     case DLL_THREAD_DETACH:
162 |     case DLL_PROCESS_DETACH:
163 |         break;
164 |     }
165 |     return TRUE;
166 | }
167 | 
168 | 


--------------------------------------------------------------------------------
/ExeIntegrityBypassAgainstRGL/ExeIntegrityBypassAgainstRGL.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup Label="ProjectConfigurations">
  4 |     <ProjectConfiguration Include="Debug|Win32">
  5 |       <Configuration>Debug</Configuration>
  6 |       <Platform>Win32</Platform>
  7 |     </ProjectConfiguration>
  8 |     <ProjectConfiguration Include="Release|Win32">
  9 |       <Configuration>Release</Configuration>
 10 |       <Platform>Win32</Platform>
 11 |     </ProjectConfiguration>
 12 |     <ProjectConfiguration Include="Debug|x64">
 13 |       <Configuration>Debug</Configuration>
 14 |       <Platform>x64</Platform>
 15 |     </ProjectConfiguration>
 16 |     <ProjectConfiguration Include="Release|x64">
 17 |       <Configuration>Release</Configuration>
 18 |       <Platform>x64</Platform>
 19 |     </ProjectConfiguration>
 20 |   </ItemGroup>
 21 |   <PropertyGroup Label="Globals">
 22 |     <VCProjectVersion>16.0</VCProjectVersion>
 23 |     <Keyword>Win32Proj</Keyword>
 24 |     <ProjectGuid>{3350dce0-9d8a-4345-853f-8b9c658aaa45}</ProjectGuid>
 25 |     <RootNamespace>ExeIntegrityBypassAgainstRGL</RootNamespace>
 26 |     <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
 27 |   </PropertyGroup>
 28 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 29 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 30 |     <ConfigurationType>DynamicLibrary</ConfigurationType>
 31 |     <UseDebugLibraries>true</UseDebugLibraries>
 32 |     <PlatformToolset>v143</PlatformToolset>
 33 |     <CharacterSet>Unicode</CharacterSet>
 34 |   </PropertyGroup>
 35 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 36 |     <ConfigurationType>DynamicLibrary</ConfigurationType>
 37 |     <UseDebugLibraries>false</UseDebugLibraries>
 38 |     <PlatformToolset>v143</PlatformToolset>
 39 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 40 |     <CharacterSet>Unicode</CharacterSet>
 41 |   </PropertyGroup>
 42 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
 43 |     <ConfigurationType>DynamicLibrary</ConfigurationType>
 44 |     <UseDebugLibraries>true</UseDebugLibraries>
 45 |     <PlatformToolset>v143</PlatformToolset>
 46 |     <CharacterSet>Unicode</CharacterSet>
 47 |   </PropertyGroup>
 48 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
 49 |     <ConfigurationType>DynamicLibrary</ConfigurationType>
 50 |     <UseDebugLibraries>false</UseDebugLibraries>
 51 |     <PlatformToolset>v143</PlatformToolset>
 52 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 53 |     <CharacterSet>Unicode</CharacterSet>
 54 |   </PropertyGroup>
 55 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 56 |   <ImportGroup Label="ExtensionSettings">
 57 |   </ImportGroup>
 58 |   <ImportGroup Label="Shared">
 59 |   </ImportGroup>
 60 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 61 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 62 |   </ImportGroup>
 63 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 64 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 65 |   </ImportGroup>
 66 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 67 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 68 |   </ImportGroup>
 69 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 70 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 71 |   </ImportGroup>
 72 |   <PropertyGroup Label="UserMacros" />
 73 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
 74 |     <TargetExt>.asi</TargetExt>
 75 |     <IntDir>obj\$(Configuration)\</IntDir>
 76 |     <OutDir>bin\$(Configuration)\</OutDir>
 77 |   </PropertyGroup>
 78 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
 79 |     <TargetExt>.asi</TargetExt>
 80 |     <IntDir>obj\$(Configuration)\</IntDir>
 81 |     <OutDir>bin\$(Configuration)\</OutDir>
 82 |   </PropertyGroup>
 83 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 84 |     <ClCompile>
 85 |       <WarningLevel>Level3</WarningLevel>
 86 |       <SDLCheck>true</SDLCheck>
 87 |       <PreprocessorDefinitions>WIN32;_DEBUG;EXEINTEGRITYBYPASSAGAINSTRGL_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 88 |       <ConformanceMode>true</ConformanceMode>
 89 |       <PrecompiledHeader>Use</PrecompiledHeader>
 90 |       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
 91 |     </ClCompile>
 92 |     <Link>
 93 |       <SubSystem>Windows</SubSystem>
 94 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 95 |       <EnableUAC>false</EnableUAC>
 96 |     </Link>
 97 |   </ItemDefinitionGroup>
 98 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 99 |     <ClCompile>
100 |       <WarningLevel>Level3</WarningLevel>
101 |       <FunctionLevelLinking>true</FunctionLevelLinking>
102 |       <IntrinsicFunctions>true</IntrinsicFunctions>
103 |       <SDLCheck>true</SDLCheck>
104 |       <PreprocessorDefinitions>WIN32;NDEBUG;EXEINTEGRITYBYPASSAGAINSTRGL_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
105 |       <ConformanceMode>true</ConformanceMode>
106 |       <PrecompiledHeader>Use</PrecompiledHeader>
107 |       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
108 |     </ClCompile>
109 |     <Link>
110 |       <SubSystem>Windows</SubSystem>
111 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
112 |       <OptimizeReferences>true</OptimizeReferences>
113 |       <GenerateDebugInformation>true</GenerateDebugInformation>
114 |       <EnableUAC>false</EnableUAC>
115 |     </Link>
116 |   </ItemDefinitionGroup>
117 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
118 |     <ClCompile>
119 |       <WarningLevel>Level3</WarningLevel>
120 |       <SDLCheck>true</SDLCheck>
121 |       <PreprocessorDefinitions>_DEBUG;EXEINTEGRITYBYPASSAGAINSTRGL_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
122 |       <ConformanceMode>true</ConformanceMode>
123 |       <PrecompiledHeader>Use</PrecompiledHeader>
124 |       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
125 |     </ClCompile>
126 |     <Link>
127 |       <SubSystem>Windows</SubSystem>
128 |       <GenerateDebugInformation>true</GenerateDebugInformation>
129 |       <EnableUAC>false</EnableUAC>
130 |     </Link>
131 |   </ItemDefinitionGroup>
132 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
133 |     <ClCompile>
134 |       <WarningLevel>Level3</WarningLevel>
135 |       <FunctionLevelLinking>true</FunctionLevelLinking>
136 |       <IntrinsicFunctions>true</IntrinsicFunctions>
137 |       <SDLCheck>true</SDLCheck>
138 |       <PreprocessorDefinitions>NDEBUG;EXEINTEGRITYBYPASSAGAINSTRGL_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
139 |       <ConformanceMode>true</ConformanceMode>
140 |       <PrecompiledHeader>Use</PrecompiledHeader>
141 |       <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
142 |       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
143 |       <LanguageStandard>stdcpplatest</LanguageStandard>
144 |     </ClCompile>
145 |     <Link>
146 |       <SubSystem>Windows</SubSystem>
147 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
148 |       <OptimizeReferences>true</OptimizeReferences>
149 |       <GenerateDebugInformation>true</GenerateDebugInformation>
150 |       <EnableUAC>false</EnableUAC>
151 |     </Link>
152 |   </ItemDefinitionGroup>
153 |   <ItemGroup>
154 |     <ClInclude Include="framework.h" />
155 |     <ClInclude Include="Logger.h" />
156 |     <ClInclude Include="pch.h" />
157 |   </ItemGroup>
158 |   <ItemGroup>
159 |     <ClCompile Include="dllmain.cpp" />
160 |     <ClCompile Include="Logger.cpp" />
161 |     <ClCompile Include="pch.cpp">
162 |       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
163 |       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
164 |       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
165 |       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
166 |     </ClCompile>
167 |   </ItemGroup>
168 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
169 |   <ImportGroup Label="ExtensionTargets">
170 |   </ImportGroup>
171 | </Project>


--------------------------------------------------------------------------------