399 lines
16 KiB
C#
399 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using BepInEx;
|
|
using BepInEx.Logging;
|
|
using Google.Protobuf;
|
|
using HarmonyLib;
|
|
using UnityEngine;
|
|
using UnityEngine.Networking;
|
|
|
|
namespace Bd2CaptureEnvironment;
|
|
|
|
[BepInPlugin(Guid, Name, Version)]
|
|
public sealed class Plugin : BaseUnityPlugin
|
|
{
|
|
public const string Guid = "bd2.capture.environment";
|
|
public const string Name = "BD2 Capture Environment";
|
|
public const string Version = "0.1.1";
|
|
|
|
private const int MaxBodyBytes = 16 * 1024 * 1024;
|
|
private const string PlayerPrefsPrefix = "BD2OfficialCapture23413:";
|
|
private static readonly object FileLock = new object();
|
|
private static ManualLogSource Log;
|
|
private static string CaptureDirectory;
|
|
private static string JsonlPath;
|
|
private static string IsolatedDataDirectory;
|
|
private static string SharedGameDataDirectory;
|
|
private static long Sequence;
|
|
private static long LastApiRequest;
|
|
|
|
private void Awake()
|
|
{
|
|
try
|
|
{
|
|
Log = Logger;
|
|
string root = Paths.GameRootPath;
|
|
IsolatedDataDirectory = Path.GetFullPath(Path.Combine(root, "IsolatedUserData"));
|
|
SharedGameDataDirectory = ReadRequiredArgument("-bd2SharedGameData");
|
|
if (!Directory.Exists(SharedGameDataDirectory))
|
|
throw new DirectoryNotFoundException(
|
|
"Shared GameData directory not found: " + SharedGameDataDirectory);
|
|
CaptureDirectory = Path.GetFullPath(Path.Combine(
|
|
root, "Capture", DateTime.Now.ToString("yyyyMMdd-HHmmss")));
|
|
JsonlPath = Path.Combine(CaptureDirectory, "capture.jsonl");
|
|
Directory.CreateDirectory(IsolatedDataDirectory);
|
|
Directory.CreateDirectory(Path.Combine(CaptureDirectory, "bodies"));
|
|
|
|
var harmony = new Harmony(Guid);
|
|
InstallStorageIsolation(harmony);
|
|
string effectiveDataPath = Application.persistentDataPath;
|
|
if (!string.Equals(
|
|
Path.GetFullPath(effectiveDataPath).TrimEnd(Path.DirectorySeparatorChar),
|
|
IsolatedDataDirectory.TrimEnd(Path.DirectorySeparatorChar),
|
|
StringComparison.OrdinalIgnoreCase))
|
|
throw new InvalidOperationException(
|
|
"persistentDataPath isolation verification failed: " + effectiveDataPath);
|
|
InstallRawCapture(harmony);
|
|
InstallPlaintextCapture(harmony);
|
|
WriteMetadata();
|
|
Logger.LogInfo("Official capture environment active");
|
|
Logger.LogInfo("persistentDataPath => " + IsolatedDataDirectory);
|
|
Logger.LogInfo("shared GameData => " + SharedGameDataDirectory);
|
|
Logger.LogInfo("capture => " + CaptureDirectory);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logger.LogError("Capture environment setup failed: " + ex);
|
|
}
|
|
}
|
|
|
|
private static string ReadRequiredArgument(string name)
|
|
{
|
|
string[] arguments = Environment.GetCommandLineArgs();
|
|
for (int i = 0; i + 1 < arguments.Length; i++)
|
|
{
|
|
if (string.Equals(arguments[i], name, StringComparison.OrdinalIgnoreCase) &&
|
|
!string.IsNullOrWhiteSpace(arguments[i + 1]))
|
|
return Path.GetFullPath(arguments[i + 1]);
|
|
}
|
|
throw new ArgumentException("Required command-line argument is missing: " + name);
|
|
}
|
|
|
|
private static void InstallStorageIsolation(Harmony harmony)
|
|
{
|
|
PropertyInfo persistent = typeof(Application).GetProperty(
|
|
"persistentDataPath", BindingFlags.Static | BindingFlags.Public);
|
|
MethodInfo getter = persistent?.GetGetMethod();
|
|
if (getter == null)
|
|
throw new MissingMethodException("Application.persistentDataPath getter not found");
|
|
harmony.Patch(getter, prefix: new HarmonyMethod(
|
|
typeof(Plugin), nameof(PersistentDataPathPrefix)));
|
|
|
|
var names = new HashSet<string>(StringComparer.Ordinal)
|
|
{
|
|
"GetString", "SetString", "GetInt", "SetInt", "GetFloat", "SetFloat",
|
|
"HasKey", "DeleteKey"
|
|
};
|
|
foreach (MethodInfo method in typeof(PlayerPrefs).GetMethods(
|
|
BindingFlags.Static | BindingFlags.Public))
|
|
{
|
|
ParameterInfo[] parameters = method.GetParameters();
|
|
if (!names.Contains(method.Name) || parameters.Length == 0 ||
|
|
parameters[0].ParameterType != typeof(string))
|
|
continue;
|
|
harmony.Patch(method, prefix: new HarmonyMethod(
|
|
typeof(Plugin), nameof(PlayerPrefsKeyPrefix)));
|
|
}
|
|
|
|
MethodInfo deleteAll = typeof(PlayerPrefs).GetMethod(
|
|
"DeleteAll", BindingFlags.Static | BindingFlags.Public,
|
|
null, Type.EmptyTypes, null);
|
|
if (deleteAll != null)
|
|
harmony.Patch(deleteAll, prefix: new HarmonyMethod(
|
|
typeof(Plugin), nameof(BlockPlayerPrefsDeleteAll)));
|
|
}
|
|
|
|
private static bool PersistentDataPathPrefix(ref string __result)
|
|
{
|
|
__result = IsolatedDataDirectory;
|
|
return false;
|
|
}
|
|
|
|
private static void PlayerPrefsKeyPrefix(ref string key)
|
|
{
|
|
if (key != null && !key.StartsWith(PlayerPrefsPrefix, StringComparison.Ordinal))
|
|
key = PlayerPrefsPrefix + key;
|
|
}
|
|
|
|
private static bool BlockPlayerPrefsDeleteAll()
|
|
{
|
|
Log?.LogWarning("Blocked PlayerPrefs.DeleteAll to protect the primary client profile");
|
|
return false;
|
|
}
|
|
|
|
private static void InstallRawCapture(Harmony harmony)
|
|
{
|
|
MethodInfo send = typeof(UnityWebRequest).GetMethod(
|
|
"SendWebRequest", BindingFlags.Instance | BindingFlags.Public,
|
|
null, Type.EmptyTypes, null);
|
|
if (send == null)
|
|
throw new MissingMethodException("UnityWebRequest.SendWebRequest not found");
|
|
harmony.Patch(send,
|
|
prefix: new HarmonyMethod(typeof(Plugin), nameof(SendWebRequestPrefix)),
|
|
postfix: new HarmonyMethod(typeof(Plugin), nameof(SendWebRequestPostfix)));
|
|
}
|
|
|
|
private sealed class RequestState
|
|
{
|
|
public long Id;
|
|
public string Method;
|
|
public string Host;
|
|
public string Path;
|
|
public bool Capture;
|
|
}
|
|
|
|
private static void SendWebRequestPrefix(UnityWebRequest __instance, out RequestState __state)
|
|
{
|
|
__state = null;
|
|
try
|
|
{
|
|
if (__instance == null || !TrySafeUri(__instance.url, out Uri uri) ||
|
|
!IsGameApi(uri, __instance.method))
|
|
return;
|
|
var state = new RequestState
|
|
{
|
|
Id = Interlocked.Increment(ref Sequence),
|
|
Method = __instance.method ?? "",
|
|
Host = uri.Host,
|
|
Path = uri.AbsolutePath,
|
|
Capture = true
|
|
};
|
|
__state = state;
|
|
Interlocked.Exchange(ref LastApiRequest, state.Id);
|
|
byte[] body = null;
|
|
try { body = __instance.uploadHandler?.data; } catch { }
|
|
string file = SaveBody(state.Id, "req", state.Path, body);
|
|
Emit("req", state.Id, state.Method, state.Host, state.Path, 0,
|
|
body?.Length ?? 0, file, null, null);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log?.LogWarning("request capture failed: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private static void SendWebRequestPostfix(
|
|
UnityWebRequest __instance, UnityWebRequestAsyncOperation __result,
|
|
RequestState __state)
|
|
{
|
|
if (__state == null || !__state.Capture || __result == null)
|
|
return;
|
|
__result.completed += delegate
|
|
{
|
|
try
|
|
{
|
|
byte[] body = null;
|
|
string error = null;
|
|
long responseCode = 0;
|
|
string result = null;
|
|
try { body = __instance.downloadHandler?.data; }
|
|
catch (Exception ex) { error = AppendError(error, ex.Message); }
|
|
try { responseCode = (long)__instance.responseCode; }
|
|
catch (Exception ex) { error = AppendError(error, ex.Message); }
|
|
try { result = __instance.result.ToString(); }
|
|
catch (Exception ex) { error = AppendError(error, ex.Message); }
|
|
try { error = AppendError(error, __instance.error); }
|
|
catch (Exception ex) { error = AppendError(error, ex.Message); }
|
|
string file = SaveBody(__state.Id, "resp", __state.Path, body);
|
|
Emit("resp", __state.Id, __state.Method, __state.Host, __state.Path,
|
|
responseCode, body?.Length ?? 0, file, result, error);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log?.LogWarning("response capture failed: " + ex.Message);
|
|
}
|
|
};
|
|
}
|
|
|
|
private static string AppendError(string current, string next)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(next)) return current;
|
|
return string.IsNullOrWhiteSpace(current) ? next : current + "; " + next;
|
|
}
|
|
|
|
private static void InstallPlaintextCapture(Harmony harmony)
|
|
{
|
|
Type manager = FindType("BDNetwork.NetworkManager");
|
|
MethodInfo gameDataPath = manager?.GetMethod("GetPachedGameDataPath",
|
|
BindingFlags.Instance | BindingFlags.Public);
|
|
if (gameDataPath == null)
|
|
throw new MissingMethodException("NetworkManager.GetPachedGameDataPath not found");
|
|
harmony.Patch(gameDataPath, prefix: new HarmonyMethod(
|
|
typeof(Plugin), nameof(GameDataPathPrefix)));
|
|
Log?.LogInfo("Shared GameData path hook installed");
|
|
|
|
MethodInfo send = manager?.GetMethods(BindingFlags.Instance | BindingFlags.Public)
|
|
.FirstOrDefault(method => method.Name == "Send" &&
|
|
method.GetParameters().Length == 6 &&
|
|
typeof(IMessage).IsAssignableFrom(method.GetParameters()[0].ParameterType));
|
|
if (send != null)
|
|
{
|
|
harmony.Patch(send, prefix: new HarmonyMethod(
|
|
typeof(Plugin), nameof(GameSendPrefix)));
|
|
Log?.LogInfo("Plaintext request capture installed");
|
|
}
|
|
else
|
|
{
|
|
Log?.LogWarning("NetworkManager.Send plaintext hook not found");
|
|
}
|
|
|
|
MethodInfo decrypt = manager?.GetMethod("AESDecrypt256",
|
|
BindingFlags.Instance | BindingFlags.Public);
|
|
if (decrypt != null)
|
|
{
|
|
harmony.Patch(decrypt, postfix: new HarmonyMethod(
|
|
typeof(Plugin), nameof(DecryptPostfix)));
|
|
Log?.LogInfo("Plaintext response capture installed");
|
|
}
|
|
else
|
|
{
|
|
Log?.LogWarning("NetworkManager.AESDecrypt256 hook not found");
|
|
}
|
|
}
|
|
|
|
private static bool GameDataPathPrefix(ref string __result)
|
|
{
|
|
__result = SharedGameDataDirectory;
|
|
return false;
|
|
}
|
|
|
|
private static void GameSendPrefix(IMessage __0)
|
|
{
|
|
try
|
|
{
|
|
if (__0 == null) return;
|
|
byte[] body = __0.ToByteArray();
|
|
long id = Interlocked.Increment(ref Sequence);
|
|
string type = __0.GetType().FullName ?? __0.GetType().Name;
|
|
string file = SaveBody(id, "proto_req", type, body);
|
|
Emit("proto_req", id, "", "", "", 0, body.Length, file, null, type);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log?.LogWarning("plaintext request capture failed: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private static void DecryptPostfix(string __result)
|
|
{
|
|
try
|
|
{
|
|
if (string.IsNullOrEmpty(__result)) return;
|
|
byte[] body = Convert.FromBase64String(__result);
|
|
long id = Interlocked.Read(ref LastApiRequest);
|
|
string file = SaveBody(id, "proto_resp", "protobuf", body);
|
|
Emit("proto_resp", id, "", "", "", 0, body.Length, file, null, null);
|
|
}
|
|
catch (FormatException) { }
|
|
catch (Exception ex)
|
|
{
|
|
Log?.LogWarning("plaintext response capture failed: " + ex.Message);
|
|
}
|
|
}
|
|
|
|
private static bool IsGameApi(Uri uri, string method)
|
|
{
|
|
if (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps)
|
|
return false;
|
|
if (string.Equals(method, "GET", StringComparison.OrdinalIgnoreCase))
|
|
return false;
|
|
string host = uri.Host ?? "";
|
|
return host.Equals("bd2.pmang.cloud", StringComparison.OrdinalIgnoreCase) ||
|
|
host.EndsWith(".bd2.pmang.cloud", StringComparison.OrdinalIgnoreCase);
|
|
}
|
|
|
|
private static bool TrySafeUri(string value, out Uri uri)
|
|
{
|
|
return Uri.TryCreate(value, UriKind.Absolute, out uri);
|
|
}
|
|
|
|
private static string SaveBody(long id, string phase, string path, byte[] body)
|
|
{
|
|
if (body == null || body.Length == 0 || body.Length > MaxBodyBytes)
|
|
return null;
|
|
string safe = new string((path ?? "body")
|
|
.Select(ch => char.IsLetterOrDigit(ch) ? ch : '_').ToArray()).Trim('_');
|
|
if (safe.Length == 0) safe = "body";
|
|
if (safe.Length > 70) safe = safe.Substring(safe.Length - 70);
|
|
string stem = id.ToString("D6") + "_" + phase + "_" + safe;
|
|
string name;
|
|
lock (FileLock)
|
|
{
|
|
name = stem + ".bin";
|
|
int duplicate = 2;
|
|
while (File.Exists(Path.Combine(CaptureDirectory, "bodies", name)))
|
|
name = stem + "_" + duplicate++ + ".bin";
|
|
File.WriteAllBytes(Path.Combine(CaptureDirectory, "bodies", name), body);
|
|
}
|
|
return "bodies/" + name;
|
|
}
|
|
|
|
private static void Emit(string ev, long id, string method, string host,
|
|
string path, long status, int length, string rawFile, string result,
|
|
string note)
|
|
{
|
|
string json = "{" +
|
|
"\"ts\":\"" + Escape(DateTime.Now.ToString("O")) + "\"," +
|
|
"\"ev\":\"" + Escape(ev) + "\"," +
|
|
"\"id\":" + id + "," +
|
|
"\"method\":\"" + Escape(method) + "\"," +
|
|
"\"host\":\"" + Escape(host) + "\"," +
|
|
"\"path\":\"" + Escape(path) + "\"," +
|
|
"\"status\":" + status + "," +
|
|
"\"length\":" + length + "," +
|
|
"\"raw_file\":" + JsonString(rawFile) + "," +
|
|
"\"result\":" + JsonString(result) + "," +
|
|
"\"note\":" + JsonString(note) + "}";
|
|
lock (FileLock)
|
|
File.AppendAllText(JsonlPath, json + Environment.NewLine, new UTF8Encoding(false));
|
|
}
|
|
|
|
private static string JsonString(string value)
|
|
{
|
|
return value == null ? "null" : "\"" + Escape(value) + "\"";
|
|
}
|
|
|
|
private static string Escape(string value)
|
|
{
|
|
if (value == null) return "";
|
|
return value.Replace("\\", "\\\\").Replace("\"", "\\\"")
|
|
.Replace("\r", "\\r").Replace("\n", "\\n");
|
|
}
|
|
|
|
private static Type FindType(string fullName)
|
|
{
|
|
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
|
|
{
|
|
Type type = assembly.GetType(fullName, false);
|
|
if (type != null) return type;
|
|
}
|
|
try { return Assembly.Load("Assembly-CSharp")?.GetType(fullName, false); }
|
|
catch { return null; }
|
|
}
|
|
|
|
private static void WriteMetadata()
|
|
{
|
|
File.WriteAllText(Path.Combine(CaptureDirectory, "README.txt"),
|
|
"BD2 2.34.13 official API capture.\r\n" +
|
|
"No Cookie/Authorization headers or URL query strings are recorded.\r\n" +
|
|
"Raw protobuf/account bodies can still contain private account data. Do not share this directory.\r\n" +
|
|
"persistentDataPath=" + IsolatedDataDirectory + "\r\n",
|
|
new UTF8Encoding(false));
|
|
}
|
|
}
|