speedmerg

Marsey/Stealthsey/Facade.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+
+namespace Marsey.Stealthsey;
+
+public static class Facade
+{
+    private static List<Type> _types = new List<Type>();
+    private static List<string> _keywords = new List<string> { "Robust", "Content", "Wizards", "Microsoft", "System" };
+
+    /// <summary>
+    /// Hides type from executing assembly
+    /// </summary>
+    private static void Imposition(Type patch)
+    {
+        if (!_types.Contains(patch)) _types.Add(patch);
+    }
+
+    /// <summary>
+    /// Hides an array of type from patch
+    /// </summary>
+    public static void Imposition(Type[] patch)
+    {
+        foreach (Type t in patch)
+            Imposition(t);
+    }
+
+    /// <summary>
+    /// Hides types of a namespace from assembly
+    /// </summary>
+    public static void Imposition(string name)
+    {
+        Type[] assemblyTypes = Assembly.GetExecutingAssembly().GetTypes();
+        foreach (Type t in assemblyTypes.Where(t => t.Namespace!.StartsWith(name)))
+        {
+            Imposition(t);
+        }
+    }
+
+    /// <summary>
+    /// Hides all types of assembly from patch
+    /// </summary>
+    /// <param name="patch"></param>
+    public static void Cloak(Assembly patch)
+    {
+        Type[] typeArray;
+        try
+        {
+            typeArray = patch.GetTypes();
+            Imposition(typeArray.Where(type => type.Namespace != null && !_keywords.Any(keyword => type.Namespace.StartsWith(keyword))).ToArray());
+        }
+        catch (ReflectionTypeLoadException)
+        {
+            MarseyLogger.Log(MarseyLogger.LogType.DEBG, $"[Facade] {patch.GetName().Name} ({Path.GetFileName(patch.Location)}): Unable to cloak types");
+        }
+    }
+
+
+    public static Type[] GetTypes() => _types.ToArray();
+}

Marsey/Stealthsey/Hidesey.cs

@@ -22,29 +22,12 @@ public static class Hidesey
     public static void Initialize() // Finally, a patch loader that loads with a patch
     {                               // Two patches even
         Hide("0Harmony");    // https://github.com/space-wizards/RobustToolbox/blob/962f5dc650297b883e8842aea8b41393d4808ac9/Robust.Client/GameController/GameController.Standalone.cs#L77
-        // Is it really insane to patch system functions?
-        MethodInfo? target = typeof(AppDomain)
-            .GetMethod("GetAssemblies", BindingFlags.Public | BindingFlags.Instance);
 
-        MethodInfo? postfix =
-            typeof(HideseyPatches)
-                .GetMethod("LieLoader", BindingFlags.Public | BindingFlags.Static)!;
+        Facade.Imposition("Marsey");
 
-        if (target == null) return;
-        Manual.Postfix(target, postfix);
-
-        target = 
-            Assembly.GetExecutingAssembly().GetType()
-                .GetMethod("GetReferencedAssemblies");
-
-        postfix =
-            typeof(HideseyPatches)
-                .GetMethod("LieReference", BindingFlags.Public | BindingFlags.Static)!;
-
-         if (target == null) return;
-         Manual.Postfix(target, postfix);
+        Perjurize(); // Patch detection methods
 
-         MarseyLogger.Log(MarseyLogger.LogType.DEBG, "Hidesey started.");
+        MarseyLogger.Log(MarseyLogger.LogType.DEBG, "Hidesey started.");
     }
 
     /// <summary>
@@ -69,8 +52,27 @@ private static void Hide(string marsey)
     /// <param name="marsey">marsey assembly</param>
     public static void Hide(Assembly marsey)
     {
+        Facade.Cloak(marsey);
         _hideseys.Add(marsey);
     }
+
+    private static void Perjurize()
+    {
+        MethodInfo? target, postfix;
+
+        target = typeof(AppDomain).GetMethod("GetAssemblies", BindingFlags.Public | BindingFlags.Instance);
+        postfix = typeof(HideseyPatches).GetMethod("LieLoader", BindingFlags.Public | BindingFlags.Static)!;
+        if (target != null) Manual.Postfix(target, postfix);
+
+        target = Assembly.GetExecutingAssembly().GetType().GetMethod("GetReferencedAssemblies");
+        postfix = typeof(HideseyPatches).GetMethod("LieReference", BindingFlags.Public | BindingFlags.Static)!;
+        if (target != null) Manual.Postfix(target, postfix);
+
+        target = typeof(Assembly).GetMethod("GetTypes");
+        postfix = typeof(HideseyPatches).GetMethod("LieTyper", BindingFlags.Public | BindingFlags.Static)!;
+        if (target != null) Manual.Postfix(target, postfix);
+    }
+
 
     /// <summary>
     /// Returns a list of only assemblies that are not hidden from a given list
@@ -89,4 +91,14 @@ public static AssemblyName[] LyingReference(AssemblyName[] original)
         AssemblyName[] result = original.Where(assembly => !hideseysNames.Contains(assembly.Name)).ToArray();
         return result;
     }
+
+    /// <summary>
+    /// Hides anything within
+    /// </summary>
+    public static Type[] LyingTyper(Type[] original)
+    {
+        Type[] hiddentypes = Facade.GetTypes();
+        return original.Except(hiddentypes).ToArray();
+    }
+
 }

Marsey/Stealthsey/HideseyPatches.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Reflection;
 
 namespace Marsey.Stealthsey;
@@ -16,11 +17,19 @@ public static void LieLoader(ref Assembly[] __result)
         __result = Hidesey.LyingDomain(__result);
     }
 
+    /// <summary>
+    /// Same but with referenced assemblies
+    /// </summary>
     public static void LieReference(ref AssemblyName[] __result)
     {
         __result = Hidesey.LyingReference(__result);
     }
 
+    public static void LieTyper(ref Type[] __result)
+    {
+        __result = Hidesey.LyingTyper(__result);
+    }
+
     /// <summary>
     /// This patch skips function execution
     /// </summary>

SS14.Loader/Program.cs

@@ -55,7 +55,6 @@ private bool Run()
             return false;
         }
 
-
         if (!TryGetLoader(clientAssembly, out var loader))
             return false;