Nico/Viano-Core
1
0 Fork 0
Code Issues Pull Requests Actions 8 Packages Projects Releases Wiki Activity

Tools/connection_patcher: remove c# code, add c++ code with minor modification, move to tools, integrate into cmake

Browse Source 
note: no longer downloads nonexistent modules
note: now throws on not finding patterns
new dependency: boost.filesystem
This commit is contained in:
bloerwald authored and Ovahlord committed 2019-09-29 00:47:38 +02:00
1 parent 31d99fb487
commit b8464b993b
22 files changed
+663 -704
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

contrib/Connection Patcher/App.config
-6
View File
@@ -1,6 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<startup>
<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0,Profile=Client"/>
</startup>
</configuration>
contrib/Connection Patcher/Connection Patcher.csproj
-69
View File
@@ -1,69 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{137B1355-6A81-4A3A-A01E-93ABAA4FFFDB}</ProjectGuid>
<OutputType>Exe</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Connection_Patcher</RootNamespace>
<AssemblyName>Connection Patcher</AssemblyName>
<TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<TargetFrameworkProfile>Client</TargetFrameworkProfile>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>TRACE;DEBUG</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<GenerateSerializationAssemblies>Off</GenerateSerializationAssemblies>
<RunCodeAnalysis>false</RunCodeAnalysis>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<PlatformTarget>AnyCPU</PlatformTarget>
<DebugType>none</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>
</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<GenerateSerializationAssemblies>Off</GenerateSerializationAssemblies>
<UseVSHostingProcess>false</UseVSHostingProcess>
</PropertyGroup>
<PropertyGroup>
<NoWin32Manifest>true</NoWin32Manifest>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
</ItemGroup>
<ItemGroup>
<Compile Include="Constants\BinaryTypes.cs" />
<Compile Include="Helper.cs" />
<Compile Include="Offsets\Windows.cs" />
<Compile Include="Patcher.cs" />
<Compile Include="Patches\Mac.cs" />
<Compile Include="Patches\Windows.cs" />
<Compile Include="Patterns\Mac.cs" />
<Compile Include="Patterns\Windows.cs" />
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
</ItemGroup>
<ItemGroup>
<None Include="App.config" />
</ItemGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>
contrib/Connection Patcher/Connection Patcher.sln
-22
View File
@@ -1,22 +0,0 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.30110.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Connection Patcher", "Connection Patcher.csproj", "{137B1355-6A81-4A3A-A01E-93ABAA4FFFDB}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{137B1355-6A81-4A3A-A01E-93ABAA4FFFDB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{137B1355-6A81-4A3A-A01E-93ABAA4FFFDB}.Debug|Any CPU.Build.0 = Debug|Any CPU
{137B1355-6A81-4A3A-A01E-93ABAA4FFFDB}.Release|Any CPU.ActiveCfg = Release|Any CPU
{137B1355-6A81-4A3A-A01E-93ABAA4FFFDB}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal
contrib/Connection Patcher/Helper.cs
-76
View File
@@ -1,76 +0,0 @@
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
*
* 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 3 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. If not, see <http://www.gnu.org/licenses/>.
*/
using Connection_Patcher.Constants;
using System;
using System.IO;
using System.Security.Cryptography;
namespace Connection_Patcher
{
class Helper
{
public static BinaryTypes GetBinaryType(byte[] data)
{
BinaryTypes type = 0u;
using (var reader = new BinaryReader(new MemoryStream(data)))
{
var magic = (uint)reader.ReadUInt16();
// Check MS-DOS magic
if (magic == 0x5A4D)
{
reader.BaseStream.Seek(0x3C, SeekOrigin.Begin);
// Read PE start offset
var peOffset = reader.ReadUInt32();
reader.BaseStream.Seek(peOffset, SeekOrigin.Begin);
var peMagic = reader.ReadUInt32();
// Check PE magic
if (peMagic != 0x4550)
throw new NotSupportedException("Not a PE file!");
type = (BinaryTypes)reader.ReadUInt16();
}
else
{
reader.BaseStream.Seek(0, SeekOrigin.Begin);
type = (BinaryTypes)reader.ReadUInt32();
}
}
return type;
}
public static string GetFileChecksum(byte[] data)
{
using (var stream = new BufferedStream(new MemoryStream(data), 1200000))
{
var sha256 = new SHA256Managed();
var checksum = sha256.ComputeHash(stream);
return BitConverter.ToString(checksum).Replace("-", "").ToLower();
}
}
}
}
contrib/Connection Patcher/Offsets/Windows.cs
-40
View File
@@ -1,40 +0,0 @@
/*
* Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
*
* 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 3 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. If not, see <http://www.gnu.org/licenses/>.
*/
namespace Connection_Patcher.Offsets
{
static class Windows
{
public static class x86
{
public static readonly long BNet = 0xD3259;
public static readonly long Send = 0x889CA;
public static readonly long Recv = 0x86EEE;
public static readonly long Signature = 0x20B79;
public static readonly long RealmList = 0x228D6C;
}
public static class x64
{
public static readonly long BNet = 0;
public static readonly long Send = 0xAAB6B;
public static readonly long Recv = 0xA9FA3;
public static readonly long Signature = 0;
public static readonly long RealmList = 0x2BB33C;
}
}
}
contrib/Connection Patcher/Patcher.cs
-130
View File
@@ -1,130 +0,0 @@
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
*
* 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 3 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. If not, see <http://www.gnu.org/licenses/>.
*/
using Connection_Patcher.Constants;
using System;
using System.IO;
namespace Connection_Patcher
{
class Patcher : IDisposable
{
public string Binary { get; set; }
public bool Initialized { get; private set; }
public BinaryTypes Type { get; private set; }
public byte[] binary;
bool success;
public Patcher(string file)
{
Initialized = false;
success = false;
using (var stream = new MemoryStream(File.ReadAllBytes(file)))
{
Binary = file;
binary = stream.ToArray();
if (binary != null)
{
Type = Helper.GetBinaryType(binary);
Initialized = true;
}
}
}
public void Patch(byte[] bytes, byte[] pattern, long address = 0)
{
if (Initialized && (address != 0 || binary.Length >= pattern.Length))
{
var offset = pattern == null ? address : SearchOffset(pattern);
Console.WriteLine("Found offset {0}", offset);
if (offset != 0 && binary.Length >= bytes.Length)
{
try
{
for (int i = 0; i < bytes.Length; i++)
binary[offset + i] = bytes[i];
}
catch (Exception ex)
{
throw new NotSupportedException(ex.Message);
}
}
}
}
long SearchOffset(byte[] pattern)
{
var matches = 0;
for (long i = 0; i < binary.Length; i++)
{
matches = 0;
for (int j = 0; j < pattern.Length; j++)
{
if (pattern.Length > (binary.Length - i))
return 0;
if (pattern[j] == 0)
{
matches++;
continue;
}
if (binary[i + j] != pattern[j])
break;
matches++;
}
if (matches == pattern.Length)
return i;
}
return 0;
}
public void Finish()
{
success = true;
}
public void Dispose()
{
try
{
if (File.Exists(Binary))
File.Delete(Binary);
if (success)
File.WriteAllBytes(Binary, binary);
}
catch (UnauthorizedAccessException)
{
}
binary = null;
}
}
}
contrib/Connection Patcher/Patches/Mac.cs
-44
View File
@@ -1,44 +0,0 @@
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
*
* 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 3 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. If not, see <http://www.gnu.org/licenses/>.
*/
namespace Connection_Patcher.Patches
{
class Mac
{
public static class x86
{
public static byte[] BNet = { };
public static byte[] Send = { };
public static byte[] Recv = { };
public static byte[] Password = { 0x0F, 0x85 };
public static byte[] Signature = { };
}
public static class x64
{
//public static byte[] BNet = { 0xB8, 0xD5, 0xF8, 0x7F, 0x82, 0x89, 0x47, 0x0C, 0x5D, 0xC3, 0x90, 0x90, 0x90 };
public static byte[] BNet = { };
//public static byte[] Send = { 0x90, 0x31, 0xDB };
public static byte[] Send = { };
public static byte[] Recv = { };
public static byte[] Password = { 0x0F, 0x85 };
//public static byte[] Signature = { 0x45, 0x31, 0xED, 0x4D, 0x89, 0xFC, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0xEB };
public static byte[] Signature = { };
}
}
}
contrib/Connection Patcher/Patches/Windows.cs
-46
View File
@@ -1,46 +0,0 @@
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
*
* 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 3 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. If not, see <http://www.gnu.org/licenses/>.
*/
namespace Connection_Patcher.Patches
{
class Windows
{
public static class x86
{
public static byte[] BNet = { 0x89, 0x48, 0x08, 0xC7, 0x40, 0x0C, 0xD5, 0xF8, 0x7F, 0x82, 0x90 };
public static byte[] Send = { 0xBA, 0x00, 0x00, 0x00, 0x00, 0x90, 0xEB };
public static byte[] Recv = { 0xB8, 0x00, 0x00, 0x00, 0x00 };
public static byte[] Password = { 0x75 };
public static byte[] Signature = { 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0xE9 };
public static byte[] RealmList = { 0x08 };
public static byte[] RealmListBn = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
}
public static class x64
{
//public static byte[] BNet = { 0xB8, 0xD5, 0xF8, 0x7F, 0x82, 0x89, 0x41, 0x0C, 0x48, 0x8B, 0xC1, 0xC3 };
public static byte[] BNet = { };
public static byte[] Send = { 0x45, 0x33, 0xED, 0x90, 0x90, 0x90 };
public static byte[] Recv = { 0xB8, 0x00, 0x00, 0x00, 0x00, 0x90 };
public static byte[] Password = { 0x75 };
public static byte[] RealmList = { 0x4C, 0x8B, 0xEA };
//public static byte[] Signature = { 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0xE9 };
public static byte[] Signature = { };
}
}
}
contrib/Connection Patcher/Program.cs
-196
View File
@@ -1,196 +0,0 @@
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
*
* 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 3 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. If not, see <http://www.gnu.org/licenses/>.
*/
using Connection_Patcher.Constants;
using System;
using System.IO;
using System.Net;
using System.Text;
using System.Threading;
namespace Connection_Patcher
{
class Program
{
static void Main(string[] args)
{
if (args.Length >= 1)
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("Client Connection Patcher");
Console.WriteLine("Press Enter to patch...");
Console.ReadKey(true);
var commonAppData = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
var modulePath = "";
var moduleFile = "";
// Let's use Win32 as default module
var patchSend = Patches.Windows.x86.Send;
var offsetSend = Offsets.Windows.x86.Send;
var patchRecv = Patches.Windows.x86.Recv;
var offsetRecv = Offsets.Windows.x86.Recv;
var patchBNet = Patches.Windows.x86.BNet;
var offsetBNet = Offsets.Windows.x86.BNet;
var patchSignature = Patches.Windows.x86.Signature;
var offsetSignature = Offsets.Windows.x86.Signature;
var fileName = args[0].Replace(".exe", "_Patched.exe");
var battleNetFileName = args[0].Replace("Wow.exe", "Battle.net.dll");
var modulePatch = Patches.Windows.x86.Password;
var modulePattern = Patterns.Windows.x86.Password;
var realmListPatch = Patches.Windows.x86.RealmList;
var realmListoffset = Offsets.Windows.x86.RealmList;
var realmListBnPatch = Patches.Windows.x86.RealmListBn;
var realmListBnPattern = Patterns.Windows.x86.RealmListBn;
Console.ForegroundColor = ConsoleColor.White;
Console.Write("Creating patched binaries for ");
using (var patcher = new Patcher(args[0]))
{
switch (patcher.Type)
{
case BinaryTypes.Pe32:
Console.WriteLine("Win32 client...");
modulePath = commonAppData + "/Blizzard Entertainment/Battle.net/Cache/";
moduleFile = "8f52906a2c85b416a595702251570f96d3522f39237603115f2f1ab24962043c.auth";
break;
//case BinaryTypes.Pe64:
// Console.WriteLine("Win64 client...");
// fileName = patcher.Binary.Replace(".exe", "") + "_Patched.exe";
// modulePath = commonAppData + "/Blizzard Entertainment/Battle.net/Cache/";
// moduleFile = "0a3afee2cade3a0e8b458c4b4660104cac7fc50e2ca9bef0d708942e77f15c1d.auth";
// break;
//case BinaryTypes.Mach32:
// break;
//case BinaryTypes.Mach64:
// Console.WriteLine("Mc64 client...");
// patchBNet = Patches.Mac.x64.BNet;
// patternBNet = Patterns.Mac.x64.BNet;
// patchSend = Patches.Mac.x64.Send;
// patternSend = Patterns.Mac.x64.Send;
// patchSignature = Patches.Mac.x64.Signature;
// patternSignature = Patterns.Mac.x64.Signature;
// fileName = patcher.Binary + " Patched";
// modulePath = "/Users/Shared/Blizzard/Battle.net/Cache/";
// moduleFile = "97eeb2e28e9e56ed6a22d09f44e2ff43c93315e006bbad43bafc0defaa6f50ae.auth";
// modulePatch = Patches.Mac.x64.Password;
// modulePattern = Patterns.Mac.x64.Password;
// break;
default:
throw new NotSupportedException("Type: " + patcher.Type + " not supported!");
}
if (!File.Exists(battleNetFileName + "_backup"))
{
File.Copy(battleNetFileName, battleNetFileName + "_backup");
File.SetAttributes(battleNetFileName + "_backup", File.GetAttributes(battleNetFileName + "_backup") | FileAttributes.ReadOnly);
}
using (var bnpatcher = new Patcher(battleNetFileName))
{
bnpatcher.Patch(patchBNet, null, offsetBNet);
bnpatcher.Patch(patchSignature, null, offsetSignature);
bnpatcher.Patch(realmListBnPatch, realmListBnPattern);
bnpatcher.Finish();
}
patcher.Patch(patchSend, null, offsetSend);
patcher.Patch(patchRecv, null, offsetRecv);
patcher.Patch(realmListPatch, null, realmListoffset);
patcher.Binary = fileName;
patcher.Finish();
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Patching done.");
CreateModule(moduleFile, modulePath, modulePatch, modulePattern);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Successfully created your patched binaries.");
}
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Wrong number of arguments: Missing client file.");
}
Console.ForegroundColor = ConsoleColor.Gray;
Thread.Sleep(5000);
Environment.Exit(0);
}
static void CreateModule(string moduleName, string path, byte[] patches, byte[] patterns)
{
var modulePath = path + moduleName[0] + moduleName[1] + "/" + moduleName[2] + moduleName[3];
var module = modulePath + "/" + moduleName;
if (!File.Exists(module))
{
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("Base module doesn't exist, downloading it...");
if (!Directory.Exists(modulePath))
Directory.CreateDirectory(modulePath);
var webClient = new WebClient();
webClient.DownloadFileCompleted += (o, e) => PatchModule(module, path, patches, patterns);
webClient.DownloadFileAsync(new Uri("http://xx.depot.battle.net:1119/" + moduleName), module);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Done.");
}
else
PatchModule(module, path, patches, patterns);
}
static void PatchModule(string file, string path, byte[] patches, byte[] pattern)
{
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("Patching module...");
using (var patcher2 = new Patcher(file))
{
patcher2.Patch(patches, pattern);
var moduleName = Helper.GetFileChecksum(patcher2.binary) + ".auth";
var modulePath = path + moduleName[0] + moduleName[1] + "/" + moduleName[2] + moduleName[3];
if (!Directory.Exists(modulePath))
Directory.CreateDirectory(modulePath);
patcher2.Binary = modulePath + "/" + moduleName;
patcher2.Finish();
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Patching module finished.");
Console.ForegroundColor = ConsoleColor.Gray;
}
}
}
contrib/Connection Patcher/Properties/AssemblyInfo.cs
-36
View File
@@ -1,36 +0,0 @@
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("Connection Patcher")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Connection Patcher")]
[assembly: AssemblyCopyright("Copyright © 2014")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("07c6905b-5b42-4804-81fe-73d0f74ebfb1")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.0.0.0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
src/tools/CMakeLists.txt
+1
View File
@@ -8,6 +8,7 @@
# WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
add_subdirectory(connection_patcher)
add_subdirectory(map_extractor)
add_subdirectory(vmap4_assembler)
add_subdirectory(vmap4_extractor)
src/tools/connection_patcher/CMakeLists.txt
+48
View File
@@ -0,0 +1,48 @@
# Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
#
# This file is free software; as a special exception the author gives
# unlimited permission to copy and/or distribute it, with or without
# modifications, as long as this notice is preserved.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
include_directories(
${CMAKE_SOURCE_DIR}
${CMAKE_SOURCE_DIR}/src/server/shared
${CMAKE_SOURCE_DIR}/src/server/shared/Cryptography
${CMAKE_SOURCE_DIR}/src/server/shared/Debugging
${CMAKE_SOURCE_DIR}/src/server/shared/Utilities
${OPENSSL_INCLUDE_DIR}
)
set(HEADER_FILES
Helper.hpp
Patcher.hpp
Constants/BinaryTypes.hpp
Patches/Mac.hpp
Patches/Windows.hpp
Patterns/Mac.hpp
Patterns/Windows.hpp
)
set(SRC_FILES
Helper.cpp
Patcher.cpp
Program.cpp
)
add_executable(connection_patcher ${HEADER_FILES} ${SRC_FILES})
target_link_libraries(connection_patcher
shared
${OPENSSL_LIBRARIES}
${Boost_LIBRARIES}
)
if (UNIX)
install(TARGETS connection_patcher DESTINATION bin)
elseif (WIN32)
install(TARGETS connection_patcher DESTINATION "${CMAKE_INSTALL_PREFIX}")
endif ()
contrib/Connection Patcher/Constants/BinaryTypes.cs → src/tools/connection_patcher/Constants/BinaryTypes.hpp
+17 -9
View File
@@ -1,6 +1,6 @@
/*
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2008-2019 TrinityCore <http://www.trinitycore.org/>
*
* 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
@@ -16,14 +16,22 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
namespace Connection_Patcher.Constants
#ifndef CONNECTION_PATCHER_CONSTANTS_BINARYTYPES_HPP
#define CONNECTION_PATCHER_CONSTANTS_BINARYTYPES_HPP
#include <cstdint>
namespace Connection_Patcher
{
enum BinaryTypes : uint
namespace Constants
{
None = 0000000000,
Pe32 = 0x0000014C,
Pe64 = 0x00008664,
Mach32 = 0xFEEDFACE,
Mach64 = 0xFEEDFACF
enum class BinaryTypes : uint32_t
{
Pe32 = 0x0000014C,
Pe64 = 0x00008664,
Mach64 = 0xFEEDFACF
};
}
}
#endif
src/tools/connection_patcher/Helper.cpp
+58
View File
@@ -0,0 +1,58 @@
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2019 TrinityCore <http://www.trinitycore.org/>
*
* 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 3 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. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Helper.hpp"
#include <SHA256.h>
#include <Util.h>
#include <stdexcept>
namespace Connection_Patcher
{
namespace Helper
{
Constants::BinaryTypes GetBinaryType(std::vector<unsigned char> const& data)
{
// Check MS-DOS magic
if (*reinterpret_cast<uint16_t const*>(data.data()) == 0x5A4D)
{
uint32_t const peOffset(*reinterpret_cast<uint32_t const*>(data.data() + 0x3C));
// Check PE magic
if (*reinterpret_cast<uint32_t const*>(data.data() + peOffset) != 0x4550)
throw std::invalid_argument("Not a PE file!");
return Constants::BinaryTypes(*reinterpret_cast<uint16_t const*>(data.data() + peOffset + 4));
}
else
{
return Constants::BinaryTypes(*reinterpret_cast<uint32_t const*>(data.data()));
}
}
std::string GetFileChecksum(std::vector<unsigned char> const& data)
{
SHA256Hash h;
h.UpdateData(data.data(), data.size());
h.Finalize();
return ByteArrayToHexStr(h.GetDigest(), h.GetLength());
}
}
}
contrib/Connection Patcher/Patterns/Mac.cs → src/tools/connection_patcher/Helper.hpp
+17 -14
View File
@@ -1,6 +1,6 @@
/*
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2008-2019 TrinityCore <http://www.trinitycore.org/>
*
* 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
@@ -16,18 +16,21 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
namespace Connection_Patcher.Patterns
{
class Mac
{
public static class x86
{
public static byte[] Password = { 0x0F, 0x84, 0xE3, 0x00, 0x00, 0x00, 0x8B, 0x03, 0x8B, 0x40, 0x04 };
}
#ifndef CONNECTION_PATCHER_HELPER_HPP
#define CONNECTION_PATCHER_HELPER_HPP
public static class x64
{
public static byte[] Password = { 0x0F, 0x84, 0x00, 0xFF, 0xFF, 0xFF, 0x49, 0x8B, 0x45, 0x00, 0xB9, 0x40 };
}
#include "Constants/BinaryTypes.hpp"
#include <vector>
#include <string>
namespace Connection_Patcher
{
namespace Helper
{
Constants::BinaryTypes GetBinaryType(std::vector<unsigned char> const& data);
std::string GetFileChecksum(std::vector<unsigned char> const& data);
}
}
#endif
src/tools/connection_patcher/Patcher.cpp
+114
View File
@@ -0,0 +1,114 @@
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2019 TrinityCore <http://www.trinitycore.org/>
*
* 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 3 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
* asize_t with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Patcher.hpp"
#include "Helper.hpp"
#include <boost/filesystem.hpp>
#include <fstream>
#include <iostream>
#include <iterator>
#include <stdexcept>
namespace
{
std::vector<unsigned char> read_file(boost::filesystem::path const& path)
{
std::ifstream ifs(path.string(), std::ifstream::binary);
if (!ifs)
throw std::runtime_error("could not open " + path.string());
ifs >> std::noskipws;
return { std::istream_iterator<unsigned char>(ifs), std::istream_iterator<unsigned char>() };
}
void write_file(boost::filesystem::path const& path, std::vector<unsigned char> const& data)
{
std::ofstream ofs(path.string(), std::ofstream::binary);
if (!ofs)
throw std::runtime_error("could not open " + path.string());
ofs << std::noskipws;
std::copy(data.begin(), data.end(), std::ostream_iterator<unsigned char>(ofs));
}
size_t SearchOffset(std::vector<unsigned char> const& binary, std::vector<unsigned char> const& pattern)
{
for (size_t i = 0; i < binary.size(); i++)
{
size_t matches = 0;
for (size_t j = 0; j < pattern.size(); j++)
{
if (pattern.size() >(binary.size() - i))
throw std::runtime_error("unable to find pattern");
if (pattern[j] == 0)
{
matches++;
continue;
}
if (binary[i + j] != pattern[j])
break;
matches++;
}
if (matches == pattern.size())
return i;
}
throw std::runtime_error("unable to find pattern");
}
}
namespace Connection_Patcher
{
Patcher::Patcher(boost::filesystem::path file)
: binary(read_file(file))
, Type(Helper::GetBinaryType(binary))
{}
void Patcher::Patch(std::vector<unsigned char> const& bytes, std::vector<unsigned char> const& pattern)
{
if (binary.size() < pattern.size())
throw std::logic_error("pattern larger than binary");
if (pattern.empty())
return;
size_t const offset(SearchOffset(binary, pattern));
std::cout << "Found offset " << offset << std::endl;
if (offset != 0 && binary.size() >= bytes.size())
for (size_t i = 0; i < bytes.size(); i++)
binary[offset + i] = bytes[i];
}
void Patcher::Finish(boost::filesystem::path out)
{
if (boost::filesystem::exists(out))
boost::filesystem::remove(out);
write_file(out, binary);
}
}
contrib/Connection Patcher/Patterns/Windows.cs → src/tools/connection_patcher/Patcher.hpp
+25 -16
View File
@@ -1,6 +1,6 @@
/*
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2015 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2008-2019 TrinityCore <http://www.trinitycore.org/>
*
* 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
@@ -16,19 +16,28 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
namespace Connection_Patcher.Patterns
{
class Windows
{
public static class x86
{
public static byte[] Password = { 0x74, 0x89, 0x8B, 0x16, 0x8B, 0x42, 0x04 };
public static byte[] RealmListBn = { 0x2E, 0x6C, 0x6F, 0x67, 0x6F, 0x6E, 0x2E, 0x62, 0x61, 0x74, 0x74, 0x6C, 0x65, 0x2E, 0x6E, 0x65, 0x74 };
}
#ifndef CONNECTION_PATCHER_PATCHER_HPP
#define CONNECTION_PATCHER_PATCHER_HPP
public static class x64
{
public static byte[] Password = { 0x74, 0x84, 0x48, 0x8B, 0x03 };
}
}
#include "Constants/BinaryTypes.hpp"
#include <boost/filesystem.hpp>
#include <vector>
#include <string>
namespace Connection_Patcher
{
struct Patcher
{
std::vector<unsigned char> binary;
Constants::BinaryTypes Type;
Patcher(boost::filesystem::path file);
void Patch(std::vector<unsigned char> const& bytes, std::vector<unsigned char> const& pattern);
void Finish(boost::filesystem::path out);
};
}
#endif
src/tools/connection_patcher/Patches/Mac.hpp
+42
View File
@@ -0,0 +1,42 @@
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2019 TrinityCore <http://www.trinitycore.org/>
*
* 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 3 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. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef CONNECTION_PATCHER_PATCHES_MAC_HPP
#define CONNECTION_PATCHER_PATCHES_MAC_HPP
#include <vector>
namespace Connection_Patcher
{
namespace Patches
{
namespace Mac
{
struct x64
{
static const std::vector<unsigned char> BNet() { return { 0xB8, 0xD5, 0xF8, 0x7F, 0x82, 0x89, 0x47, 0x0C, 0x5D, 0xC3, 0x90, 0x90, 0x90 }; }
static const std::vector<unsigned char> Portal() { return { }; }
static const std::vector<unsigned char> Connect() { return { }; }
static const std::vector<unsigned char> Password() { return { 0x0F, 0x85 }; }
static const std::vector<unsigned char> Signature() { return { 0x45, 0x31, 0xED, 0x4D, 0x89, 0xFC, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0xEB }; }
};
};
}
}
#endif
src/tools/connection_patcher/Patches/Windows.hpp
+51
View File
@@ -0,0 +1,51 @@
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2019 TrinityCore <http://www.trinitycore.org/>
*
* 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 3 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. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef CONNECTION_PATCHER_PATCHES_WINDOWS_HPP
#define CONNECTION_PATCHER_PATCHES_WINDOWS_HPP
#include <vector>
namespace Connection_Patcher
{
namespace Patches
{
namespace Windows
{
struct x86
{
static const std::vector<unsigned char> BNet() { return { 0xC7, 0x40, 0x0C, 0xD5, 0xF8, 0x7F, 0x82 }; }
static const std::vector<unsigned char> Portal() { return { }; }
static const std::vector<unsigned char> Connect() { return { 0xEB }; }
static const std::vector<unsigned char> Password() { return { 0x75 }; }
static const std::vector<unsigned char> Signature() { return { 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0xEB }; }
};
struct x64
{
static const std::vector<unsigned char> BNet() { return { 0xB8, 0xD5, 0xF8, 0x7F, 0x82, 0x89, 0x41, 0x0C, 0x48, 0x8B, 0xC1, 0xC3 }; }
static const std::vector<unsigned char> Portal() { return { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; }
static const std::vector<unsigned char> Connect() { return { 0xEB }; }
static const std::vector<unsigned char> Password() { return { 0x75 }; }
static const std::vector<unsigned char> Signature() { return { 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0xE9 }; }
};
};
}
}
#endif
src/tools/connection_patcher/Patterns/Mac.hpp
+42
View File
@@ -0,0 +1,42 @@
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2019 TrinityCore <http://www.trinitycore.org/>
*
* 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 3 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. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef CONNECTION_PATCHER_PATTERNS_MAC_HPP
#define CONNECTION_PATCHER_PATTERNS_MAC_HPP
#include <vector>
namespace Connection_Patcher
{
namespace Patterns
{
namespace Mac
{
struct x64
{
static const std::vector<unsigned char> BNet() { return { 0x8B, 0x06, 0x89, 0x47, 0x0C, 0x5D, 0xC3 }; }
static const std::vector<unsigned char> Portal() { return { }; }
static const std::vector<unsigned char> Connect() { return { }; }
static const std::vector<unsigned char> Password() { return { 0x0F, 0x84, 0x00, 0xFF, 0xFF, 0xFF, 0x49, 0x8B, 0x45, 0x00, 0xB9, 0x40 }; }
static const std::vector<unsigned char> Signature() { return { 0xE8, 0x00, 0x00, 0x00, 0x00, 0x45, 0x31, 0xED, 0x4D, 0x89, 0xFC, 0x84, 0xC0, 0x75 }; }
};
};
}
}
#endif
src/tools/connection_patcher/Patterns/Windows.hpp
+51
View File
@@ -0,0 +1,51 @@
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2019 TrinityCore <http://www.trinitycore.org/>
*
* 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 3 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. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef CONNECTION_PATCHER_PATTERNS_WINDOWS_HPP
#define CONNECTION_PATCHER_PATTERNS_WINDOWS_HPP
#include <vector>
namespace Connection_Patcher
{
namespace Patterns
{
namespace Windows
{
struct x86
{
static const std::vector<unsigned char> BNet() { return { 0x8B, 0x75, 0x08, 0x8D, 0x78, 0x0C }; }
static const std::vector<unsigned char> Portal() { return { }; }
static const std::vector<unsigned char> Connect() { return { 0x74, 0x33, 0x6A, 0x04, 0xFF, 0x75, 0xF8 }; }
static const std::vector<unsigned char> Password() { return { 0x74, 0x89, 0x8B, 0x16, 0x8B, 0x42, 0x04 }; }
static const std::vector<unsigned char> Signature() { return { 0xE8, 0x00, 0x00, 0x00, 0x00, 0x84, 0xC0, 0x75, 0x5F, 0x33, 0xC0 }; }
};
struct x64
{
static const std::vector<unsigned char> BNet() { return { 0x8B, 0x02, 0x89, 0x41, 0x0C, 0x48, 0x8B, 0xC1, 0xC3 }; }
static const std::vector<unsigned char> Portal() { return { 0x2E, 0x6C, 0x6F, 0x67, 0x6F, 0x6E, 0x2E, 0x62, 0x61, 0x74, 0x74, 0x6C, 0x65, 0x2E, 0x6E, 0x65, 0x74, 0x00 }; }
static const std::vector<unsigned char> Connect() { return { 0x74, 0x2C, 0x48, 0x8D, 0x4C, 0x24, 0x78 }; }
static const std::vector<unsigned char> Password() { return { 0x74, 0x84, 0x48, 0x8B, 0x03 }; }
static const std::vector<unsigned char> Signature() { return { 0xE8, 0x00, 0x00, 0x00, 0x00, 0x84, 0xC0, 0x0F, 0x85, 0x88, 0x00, 0x00, 0x00, 0x45, 0x33, 0xC0 }; }
};
};
}
}
#endif
src/tools/connection_patcher/Program.cpp
+197
View File
@@ -0,0 +1,197 @@
/*
* Copyright (C) 2012-2014 Arctium Emulation <http://arctium.org>
* Copyright (C) 2008-2019 TrinityCore <http://www.trinitycore.org/>
*
* 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 3 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. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Helper.hpp"
#include "Patcher.hpp"
#include "Patches/Mac.hpp"
#include "Patches/Windows.hpp"
#include "Patterns/Mac.hpp"
#include "Patterns/Windows.hpp"
#include <CompilerDefs.h>
#include <boost/algorithm/string/replace.hpp>
#include <boost/filesystem.hpp>
#include <iostream>
#if PLATFORM == PLATFORM_WINDOWS
#include <Shlobj.h>
#endif
namespace Connection_Patcher
{
namespace
{
template<typename PATCH, typename PATTERN>
void PatchModule(boost::filesystem::path file, boost::filesystem::path path)
{
std::cout << "Patching module...\n";
Patcher patcher(file);
std::cout << "patching Password\n";
patcher.Patch(PATCH::Password(), PATTERN::Password());
std::string const moduleName(Helper::GetFileChecksum(patcher.binary) + ".auth");
boost::filesystem::path const modulePath
(path / std::string(&moduleName[0], 2) / std::string(&moduleName[2], 2));
if (!boost::filesystem::exists(modulePath))
boost::filesystem::create_directories(modulePath);
patcher.Finish(modulePath / moduleName);
std::cout << "Patching module finished.\n";
}
template<typename PATCH, typename PATTERN>
void do_module(std::string moduleName, boost::filesystem::path path)
{
boost::filesystem::path const modulePath
(path / std::string(&moduleName[0], 2) / std::string(&moduleName[2], 2));
boost::filesystem::path const module(modulePath / moduleName);
if (!boost::filesystem::exists(module))
throw std::runtime_error("base module does not exist. run client once.");
PatchModule<PATCH, PATTERN>(module, path);
}
template<typename PATCH, typename PATTERN>
void do_patches(Patcher* patcher, boost::filesystem::path output)
{
std::cout << "patching BNet\n";
patcher->Patch(PATCH::BNet(), PATTERN::BNet());
std::cout << "patching Portal\n";
patcher->Patch(PATCH::Portal(), PATTERN::Portal());
std::cout << "patching Connect\n";
patcher->Patch(PATCH::Connect(), PATTERN::Connect());
std::cout << "patching Signature\n";
patcher->Patch(PATCH::Signature(), PATTERN::Signature());
patcher->Finish(output);
std::cout << "Patching done.\n";
}
}
// adapted from http://stackoverflow.com/questions/8593608/how-can-i-copy-a-directory-using-boost-filesystem
void copyDir(boost::filesystem::path const& source, boost::filesystem::path const& destination)
{
namespace fs = boost::filesystem;
if (!fs::exists(source) || !fs::is_directory(source))
throw std::invalid_argument("Source directory " + source.string() + " does not exist or is not a directory.");
if (fs::exists(destination))
throw std::invalid_argument("Destination directory " + destination.string() + " already exists.");
if (!fs::create_directory(destination))
throw std::runtime_error("Unable to create destination directory" + destination.string());
for (fs::directory_iterator file(source); file != fs::directory_iterator(); ++file)
{
fs::path current(file->path());
if (fs::is_directory(current))
copyDir(current, destination / current.filename());
else
fs::copy_file(current, destination / current.filename());
}
}
}
int main(int argc, char** argv)
{
using namespace Connection_Patcher;
try
{
if (argc != 2)
throw std::invalid_argument("Wrong number of arguments: Missing client file.");
std::string const binary_path(argv[1]);
std::string renamed_binary_path(binary_path);
wchar_t* commonAppData(nullptr);
#if PLATFORM == PLATFORM_WINDOWS
SHGetKnownFolderPath(FOLDERID_ProgramData, 0, NULL, &commonAppData);
#endif
std::cout << "Creating patched binaries for ";
Patcher patcher(binary_path);
switch (patcher.Type)
{
case Constants::BinaryTypes::Pe32:
std::cout << "Win32 client...\n";
boost::algorithm::replace_all(renamed_binary_path, ".exe", "_Patched.exe");
do_patches<Patches::Windows::x86, Patterns::Windows::x86>
(&patcher, renamed_binary_path);
do_module<Patches::Windows::x86, Patterns::Windows::x86>
("8f52906a2c85b416a595702251570f96d3522f39237603115f2f1ab24962043c.auth"
, std::wstring(commonAppData) + std::wstring(L"/Blizzard Entertainment/Battle.net/Cache/")
);
break;
case Constants::BinaryTypes::Pe64:
std::cout << "Win64 client...\n";
boost::algorithm::replace_all(renamed_binary_path, ".exe", "_Patched.exe");
do_patches<Patches::Windows::x64, Patterns::Windows::x64>
(&patcher, renamed_binary_path);
do_module<Patches::Windows::x64, Patterns::Windows::x64>
("0a3afee2cade3a0e8b458c4b4660104cac7fc50e2ca9bef0d708942e77f15c1d.auth"
, std::wstring(commonAppData) + std::wstring(L"/Blizzard Entertainment/Battle.net/Cache/")
);
break;
case Constants::BinaryTypes::Mach64:
std::cout << "Mac client...\n";
boost::algorithm::replace_all(renamed_binary_path, ".app", " Patched.app");
copyDir(boost::filesystem::path(binary_path).parent_path()/*MacOS*/.parent_path()/*Contents*/.parent_path()
, boost::filesystem::path(renamed_binary_path).parent_path()/*MacOS*/.parent_path()/*Contents*/.parent_path()
);
do_patches<Patches::Mac::x64, Patterns::Mac::x64>
(&patcher, renamed_binary_path);
do_module<Patches::Windows::x64, Patterns::Windows::x64>
("97eeb2e28e9e56ed6a22d09f44e2ff43c93315e006bbad43bafc0defaa6f50ae.auth"
, "/Users/Shared/Blizzard/Battle.net/Cache/"
);
break;
default:
throw std::runtime_error("Type: " + std::to_string(static_cast<uint32_t>(patcher.Type)) + " not supported!");
}
std::cout << "Successfully created your patched binaries.\n";
return 0;
}
catch (std::exception const& ex)
{
std::cerr << "EX: " << ex.what() << std::endl;
return 1;
}
}