Paper/patches/server/0022-Remap-reflection-calls-in-plugins-using-internals.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Nassim Jahnke <nassim@njahnke.dev>
Date: Sun, 30 Oct 2022 23:47:26 +0100
Subject: [PATCH] Remap reflection calls in plugins using internals

Co-authored-by: Jason Penilla <11360596+jpenilla@users.noreply.github.com>

diff --git a/build.gradle.kts b/build.gradle.kts
index 9086a65f5d593eea72a89d1153f6d353dfac1619..e1cfa2188dbe583a0180be2243a7a554dc5412d7 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -48,6 +48,12 @@ dependencies {
     testImplementation("org.junit-pioneer:junit-pioneer:2.2.0") // Paper - CartesianTest
     implementation("net.neoforged:srgutils:1.0.9") // Paper - mappings handling
     implementation("net.neoforged:AutoRenamingTool:2.0.3") // Paper - remap plugins
+    // Paper start - Remap reflection
+    val reflectionRewriterVersion = "0.0.3"
+    implementation("io.papermc:reflection-rewriter:$reflectionRewriterVersion")
+    implementation("io.papermc:reflection-rewriter-runtime:$reflectionRewriterVersion")
+    implementation("io.papermc:reflection-rewriter-proxy-generator:$reflectionRewriterVersion")
+    // Paper end - Remap reflection
 }
 
 paperweight {
diff --git a/src/main/java/io/papermc/paper/configuration/serializer/PacketClassSerializer.java b/src/main/java/io/papermc/paper/configuration/serializer/PacketClassSerializer.java
index 893ad5e7c2d32ccd64962d95d146bbd317c28ab8..3d73ea0e63c97b2b08e719b7be7af3894fb2d4e8 100644
--- a/src/main/java/io/papermc/paper/configuration/serializer/PacketClassSerializer.java
+++ b/src/main/java/io/papermc/paper/configuration/serializer/PacketClassSerializer.java
@@ -5,6 +5,7 @@ import com.google.common.collect.ImmutableBiMap;
 import com.mojang.logging.LogUtils;
 import io.leangen.geantyref.TypeToken;
 import io.papermc.paper.configuration.serializer.collections.MapSerializer;
+import io.papermc.paper.util.MappingEnvironment;
 import io.papermc.paper.util.ObfHelper;
 import net.minecraft.network.protocol.Packet;
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -69,7 +70,7 @@ public final class PacketClassSerializer extends ScalarSerializer<Class<? extend
     @Override
     protected @Nullable Object serialize(final Class<? extends Packet<?>> packetClass, final Predicate<Class<?>> typeSupported) {
         final String name = packetClass.getName();
-        @Nullable String mojName = ObfHelper.INSTANCE.mappingsByMojangName() == null ? name : MOJANG_TO_OBF.inverse().get(name); // if the mappings are null, running on moj-mapped server
+        @Nullable String mojName = ObfHelper.INSTANCE.mappingsByMojangName() == null || !MappingEnvironment.reobf() ? name : MOJANG_TO_OBF.inverse().get(name); // if the mappings are null, running on moj-mapped server
         if (mojName == null && MOJANG_TO_OBF.containsKey(name)) {
             mojName = name;
         }
diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/classloader/BytecodeModifyingURLClassLoader.java b/src/main/java/io/papermc/paper/plugin/entrypoint/classloader/BytecodeModifyingURLClassLoader.java
new file mode 100644
index 0000000000000000000000000000000000000000..1240c061c121e8d5eb9add4e5e21955ee6df9368
--- /dev/null
+++ b/src/main/java/io/papermc/paper/plugin/entrypoint/classloader/BytecodeModifyingURLClassLoader.java
@@ -0,0 +1,187 @@
+package io.papermc.paper.plugin.entrypoint.classloader;
+
+import io.papermc.paper.pluginremap.reflect.ReflectionRemapper;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UncheckedIOException;
+import java.net.JarURLConnection;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.security.CodeSigner;
+import java.security.CodeSource;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.jar.Attributes;
+import java.util.jar.Manifest;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+
+import static java.util.Objects.requireNonNullElse;
+
+public final class BytecodeModifyingURLClassLoader extends URLClassLoader {
+    static {
+        ClassLoader.registerAsParallelCapable();
+    }
+
+    private static final Object MISSING_MANIFEST = new Object();
+
+    private final Function<byte[], byte[]> modifier;
+    private final Map<String, Object> manifests = new ConcurrentHashMap<>();
+
+    public BytecodeModifyingURLClassLoader(
+        final URL[] urls,
+        final ClassLoader parent,
+        final Function<byte[], byte[]> modifier
+    ) {
+        super(urls, parent);
+        this.modifier = modifier;
+    }
+
+    public BytecodeModifyingURLClassLoader(
+        final URL[] urls,
+        final ClassLoader parent
+    ) {
+        this(urls, parent, bytes -> {
+            final ClassReader classReader = new ClassReader(bytes);
+            final ClassWriter classWriter = new ClassWriter(classReader, 0);
+            final ClassVisitor visitor = ReflectionRemapper.visitor(classWriter);
+            if (visitor == classWriter) {
+                return bytes;
+            }
+            classReader.accept(visitor, 0);
+            return classWriter.toByteArray();
+        });
+    }
+
+    @Override
+    protected Class<?> findClass(final String name) throws ClassNotFoundException {
+        final Class<?> result;
+        final String path = name.replace('.', '/').concat(".class");
+        final URL url = this.findResource(path);
+        if (url != null) {
+            try {
+                result = this.defineClass(name, url);
+            } catch (final IOException e) {
+                throw new ClassNotFoundException(name, e);
+            }
+        } else {
+            result = null;
+        }
+        if (result == null) {
+            throw new ClassNotFoundException(name);
+        }
+        return result;
+    }
+
+    private Class<?> defineClass(String name, URL url) throws IOException {
+        int i = name.lastIndexOf('.');
+        if (i != -1) {
+            String pkgname = name.substring(0, i);
+            // Check if package already loaded.
+            final @Nullable Manifest man = this.manifestFor(url);
+            final URL jarUrl = URI.create(jarName(url)).toURL();
+            if (this.getAndVerifyPackage(pkgname, man, jarUrl) == null) {
+                try {
+                    if (man != null) {
+                        this.definePackage(pkgname, man, jarUrl);
+                    } else {
+                        this.definePackage(pkgname, null, null, null, null, null, null, null);
+                    }
+                } catch (IllegalArgumentException iae) {
+                    // parallel-capable class loaders: re-verify in case of a
+                    // race condition
+                    if (this.getAndVerifyPackage(pkgname, man, jarUrl) == null) {
+                        // Should never happen
+                        throw new AssertionError("Cannot find package " +
+                            pkgname);
+                    }
+                }
+            }
+        }
+        final byte[] bytes;
+        try (final InputStream is = url.openStream()) {
+            bytes = is.readAllBytes();
+        }
+
+        final byte[] modified = this.modifier.apply(bytes);
+
+        final CodeSource cs = new CodeSource(url, (CodeSigner[]) null);
+        return this.defineClass(name, modified, 0, modified.length, cs);
+    }
+
+    private Package getAndVerifyPackage(
+        String pkgname,
+        Manifest man, URL url
+    ) {
+        Package pkg = getDefinedPackage(pkgname);
+        if (pkg != null) {
+            // Package found, so check package sealing.
+            if (pkg.isSealed()) {
+                // Verify that code source URL is the same.
+                if (!pkg.isSealed(url)) {
+                    throw new SecurityException(
+                        "sealing violation: package " + pkgname + " is sealed");
+                }
+            } else {
+                // Make sure we are not attempting to seal the package
+                // at this code source URL.
+                if ((man != null) && this.isSealed(pkgname, man)) {
+                    throw new SecurityException(
+                        "sealing violation: can't seal package " + pkgname +
+                            ": already loaded");
+                }
+            }
+        }
+        return pkg;
+    }
+
+    private boolean isSealed(String name, Manifest man) {
+        Attributes attr = man.getAttributes(name.replace('.', '/').concat("/"));
+        String sealed = null;
+        if (attr != null) {
+            sealed = attr.getValue(Attributes.Name.SEALED);
+        }
+        if (sealed == null) {
+            if ((attr = man.getMainAttributes()) != null) {
+                sealed = attr.getValue(Attributes.Name.SEALED);
+            }
+        }
+        return "true".equalsIgnoreCase(sealed);
+    }
+
+    private @Nullable Manifest manifestFor(final URL url) throws IOException {
+        Manifest man = null;
+        if (url.getProtocol().equals("jar")) {
+            try {
+                final Object computedManifest = this.manifests.computeIfAbsent(jarName(url), $ -> {
+                    try {
+                        final Manifest m = ((JarURLConnection) url.openConnection()).getManifest();
+                        return requireNonNullElse(m, MISSING_MANIFEST);
+                    } catch (final IOException e) {
+                        throw new UncheckedIOException(e);
+                    }
+                });
+                if (computedManifest instanceof Manifest found) {
+                    man = found;
+                }
+            } catch (final UncheckedIOException e) {
+                throw e.getCause();
+            } catch (final IllegalArgumentException e) {
+                throw new IOException(e);
+            }
+        }
+        return man;
+    }
+
+    private static String jarName(final URL sourceUrl) {
+        final int exclamationIdx = sourceUrl.getPath().lastIndexOf('!');
+        if (exclamationIdx != -1) {
+            return sourceUrl.getPath().substring(0, exclamationIdx);
+        }
+        throw new IllegalArgumentException("Could not find jar for URL " + sourceUrl);
+    }
+}
diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/classloader/PaperClassloaderBytecodeModifier.java b/src/main/java/io/papermc/paper/plugin/entrypoint/classloader/PaperClassloaderBytecodeModifier.java
index f9a2c55a354c877749db3f92956de802ae575788..0e734c07dbe82ba4c319a237f9e79b08b57b997f 100644
--- a/src/main/java/io/papermc/paper/plugin/entrypoint/classloader/PaperClassloaderBytecodeModifier.java
+++ b/src/main/java/io/papermc/paper/plugin/entrypoint/classloader/PaperClassloaderBytecodeModifier.java
@@ -7,6 +7,6 @@ public class PaperClassloaderBytecodeModifier implements ClassloaderBytecodeModi
 
     @Override
     public byte[] modify(PluginMeta configuration, byte[] bytecode) {
-        return bytecode;
+        return io.papermc.paper.pluginremap.reflect.ReflectionRemapper.processClass(bytecode);
     }
 }
diff --git a/src/main/java/io/papermc/paper/plugin/loader/PaperClasspathBuilder.java b/src/main/java/io/papermc/paper/plugin/loader/PaperClasspathBuilder.java
index f576060c8fe872772bbafe2016fc9b83a3c095f1..f871a329eb52da077f58d0ceaaabd3349f84cad0 100644
--- a/src/main/java/io/papermc/paper/plugin/loader/PaperClasspathBuilder.java
+++ b/src/main/java/io/papermc/paper/plugin/loader/PaperClasspathBuilder.java
@@ -2,12 +2,12 @@ package io.papermc.paper.plugin.loader;
 
 import io.papermc.paper.plugin.PluginInitializerManager;
 import io.papermc.paper.plugin.bootstrap.PluginProviderContext;
+import io.papermc.paper.plugin.entrypoint.classloader.BytecodeModifyingURLClassLoader;
+import io.papermc.paper.plugin.entrypoint.classloader.PaperPluginClassLoader;
 import io.papermc.paper.plugin.loader.library.ClassPathLibrary;
 import io.papermc.paper.plugin.loader.library.PaperLibraryStore;
-import io.papermc.paper.plugin.entrypoint.classloader.PaperPluginClassLoader;
 import io.papermc.paper.plugin.provider.configuration.PaperPluginMeta;
-import org.jetbrains.annotations.NotNull;
-
+import io.papermc.paper.util.MappingEnvironment;
 import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URL;
@@ -17,6 +17,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.jar.JarFile;
 import java.util.logging.Logger;
+import org.jetbrains.annotations.NotNull;
 
 public class PaperClasspathBuilder implements PluginClasspathBuilder {
 
@@ -60,7 +61,10 @@ public class PaperClasspathBuilder implements PluginClasspathBuilder {
         }
 
         try {
-            return new PaperPluginClassLoader(logger, source, jarFile, configuration, this.getClass().getClassLoader(), new URLClassLoader(urls, getClass().getClassLoader()));
+            final URLClassLoader libraryLoader = MappingEnvironment.DISABLE_PLUGIN_REMAPPING
+                ? new URLClassLoader(urls, this.getClass().getClassLoader())
+                : new BytecodeModifyingURLClassLoader(urls, this.getClass().getClassLoader());
+            return new PaperPluginClassLoader(logger, source, jarFile, configuration, this.getClass().getClassLoader(), libraryLoader);
         } catch (IOException exception) {
             throw new RuntimeException(exception);
         }
diff --git a/src/main/java/io/papermc/paper/plugin/provider/type/spigot/SpigotPluginProviderFactory.java b/src/main/java/io/papermc/paper/plugin/provider/type/spigot/SpigotPluginProviderFactory.java
index bdd9bc8a414719b9f1d6f01f90539ddb8603a878..1bf0fa1530b8e5f94d726d0313b7a00f675b500c 100644
--- a/src/main/java/io/papermc/paper/plugin/provider/type/spigot/SpigotPluginProviderFactory.java
+++ b/src/main/java/io/papermc/paper/plugin/provider/type/spigot/SpigotPluginProviderFactory.java
@@ -1,9 +1,12 @@
 package io.papermc.paper.plugin.provider.type.spigot;
 
+import io.papermc.paper.plugin.entrypoint.classloader.BytecodeModifyingURLClassLoader;
 import io.papermc.paper.plugin.provider.configuration.serializer.constraints.PluginConfigConstraints;
 import io.papermc.paper.plugin.provider.type.PluginTypeFactory;
+import io.papermc.paper.util.MappingEnvironment;
 import org.bukkit.plugin.InvalidDescriptionException;
 import org.bukkit.plugin.PluginDescriptionFile;
+import org.bukkit.plugin.java.LibraryLoader;
 import org.yaml.snakeyaml.error.YAMLException;
 
 import java.io.IOException;
@@ -15,6 +18,12 @@ import java.util.jar.JarFile;
 
 class SpigotPluginProviderFactory implements PluginTypeFactory<SpigotPluginProvider, PluginDescriptionFile> {
 
+    static {
+        if (!MappingEnvironment.DISABLE_PLUGIN_REMAPPING) {
+			LibraryLoader.LIBRARY_LOADER_FACTORY = BytecodeModifyingURLClassLoader::new;
+		}
+    }
+
     @Override
     public SpigotPluginProvider build(JarFile file, PluginDescriptionFile configuration, Path source) throws InvalidDescriptionException {
         // Copied from SimplePluginManager#loadPlugins
diff --git a/src/main/java/io/papermc/paper/pluginremap/reflect/PaperReflection.java b/src/main/java/io/papermc/paper/pluginremap/reflect/PaperReflection.java
new file mode 100644
index 0000000000000000000000000000000000000000..92bc8e4933ff13764fa2ac7f3729216332e202c9
--- /dev/null
+++ b/src/main/java/io/papermc/paper/pluginremap/reflect/PaperReflection.java
@@ -0,0 +1,211 @@
+package io.papermc.paper.pluginremap.reflect;
+
+import com.mojang.logging.LogUtils;
+import io.papermc.paper.util.MappingEnvironment;
+import io.papermc.paper.util.ObfHelper;
+import io.papermc.reflectionrewriter.runtime.AbstractDefaultRulesReflectionProxy;
+import io.papermc.reflectionrewriter.runtime.DefineClassReflectionProxy;
+import java.lang.invoke.MethodHandles;
+import java.nio.ByteBuffer;
+import java.security.CodeSource;
+import java.security.ProtectionDomain;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.checkerframework.framework.qual.DefaultQualifier;
+import org.slf4j.Logger;
+
+// todo proper inheritance handling
+@SuppressWarnings("unused")
+@DefaultQualifier(NonNull.class)
+public final class PaperReflection extends AbstractDefaultRulesReflectionProxy implements DefineClassReflectionProxy {
+    // concat to avoid being rewritten by shadow
+    private static final Logger LOGGER = LogUtils.getLogger();
+    private static final String CB_PACKAGE_PREFIX = "org.bukkit.".concat("craftbukkit.");
+    private static final String LEGACY_CB_PACKAGE_PREFIX = "org.bukkit.".concat("craftbukkit.") + MappingEnvironment.LEGACY_CB_VERSION + ".";
+
+    private final DefineClassReflectionProxy defineClassProxy;
+    private final Map<String, ObfHelper.ClassMapping> mappingsByMojangName;
+    private final Map<String, ObfHelper.ClassMapping> mappingsByObfName;
+    // Reflection does not care about method return values, so this map removes the return value descriptor from the key
+    private final Map<String, Map<String, String>> strippedMethodMappings;
+
+    PaperReflection() {
+        this.defineClassProxy = DefineClassReflectionProxy.create(PaperReflection::processClass);
+        if (!MappingEnvironment.hasMappings()) {
+            this.mappingsByMojangName = Map.of();
+            this.mappingsByObfName = Map.of();
+            this.strippedMethodMappings = Map.of();
+            return;
+        }
+        final ObfHelper obfHelper = ObfHelper.INSTANCE;
+        this.mappingsByMojangName = Objects.requireNonNull(obfHelper.mappingsByMojangName(), "mappingsByMojangName");
+        this.mappingsByObfName = Objects.requireNonNull(obfHelper.mappingsByObfName(), "mappingsByObfName");
+        this.strippedMethodMappings = this.mappingsByMojangName.entrySet().stream().collect(Collectors.toUnmodifiableMap(
+            Map.Entry::getKey,
+            entry -> entry.getValue().strippedMethods()
+        ));
+    }
+
+    @Override
+    protected String mapClassName(final String name) {
+        final ObfHelper.@Nullable ClassMapping mapping = this.mappingsByObfName.get(name);
+        return mapping != null ? mapping.mojangName() : removeCraftBukkitRelocation(name);
+    }
+
+    @Override
+    protected String mapDeclaredMethodName(final Class<?> clazz, final String name, final Class<?> @Nullable ... parameterTypes) {
+        final @Nullable Map<String, String> mapping = this.strippedMethodMappings.get(clazz.getName());
+        if (mapping == null) {
+            return name;
+        }
+        return mapping.getOrDefault(strippedMethodKey(name, parameterTypes), name);
+    }
+
+    @Override
+    protected String mapMethodName(final Class<?> clazz, final String name, final Class<?> @Nullable ... parameterTypes) {
+        final @Nullable String mapped = this.findMappedMethodName(clazz, name, parameterTypes);
+        return mapped != null ? mapped : name;
+    }
+
+    @Override
+    protected String mapDeclaredFieldName(final Class<?> clazz, final String name) {
+        final ObfHelper.@Nullable ClassMapping mapping = this.mappingsByMojangName.get(clazz.getName());
+        if (mapping == null) {
+            return name;
+        }
+        return mapping.fieldsByObf().getOrDefault(name, name);
+    }
+
+    @Override
+    protected String mapFieldName(final Class<?> clazz, final String name) {
+        final @Nullable String mapped = this.findMappedFieldName(clazz, name);
+        return mapped != null ? mapped : name;
+    }
+
+    private @Nullable String findMappedMethodName(final Class<?> clazz, final String name, final Class<?> @Nullable ... parameterTypes) {
+        final Map<String, String> map = this.strippedMethodMappings.get(clazz.getName());
+        @Nullable String mapped = null;
+        if (map != null) {
+            mapped = map.get(strippedMethodKey(name, parameterTypes));
+            if (mapped != null) {
+                return mapped;
+            }
+        }
+        // JVM checks super before interfaces
+        final Class<?> superClass = clazz.getSuperclass();
+        if (superClass != null) {
+            mapped = this.findMappedMethodName(superClass, name, parameterTypes);
+        }
+        if (mapped == null) {
+            for (final Class<?> i : clazz.getInterfaces()) {
+                mapped = this.findMappedMethodName(i, name, parameterTypes);
+                if (mapped != null) {
+                    break;
+                }
+            }
+        }
+        return mapped;
+    }
+
+    private @Nullable String findMappedFieldName(final Class<?> clazz, final String name) {
+        final ObfHelper.ClassMapping mapping = this.mappingsByMojangName.get(clazz.getName());
+        @Nullable String mapped = null;
+        if (mapping != null) {
+            mapped = mapping.fieldsByObf().get(name);
+            if (mapped != null) {
+                return mapped;
+            }
+        }
+        // The JVM checks super before interfaces
+        final Class<?> superClass = clazz.getSuperclass();
+        if (superClass != null) {
+            mapped = this.findMappedFieldName(superClass, name);
+        }
+        if (mapped == null) {
+            for (final Class<?> i : clazz.getInterfaces()) {
+                mapped = this.findMappedFieldName(i, name);
+                if (mapped != null) {
+                    break;
+                }
+            }
+        }
+        return mapped;
+    }
+
+    private static String strippedMethodKey(final String methodName, final Class<?> @Nullable ... parameterTypes) {
+        return methodName + parameterDescriptor(parameterTypes);
+    }
+
+    private static String parameterDescriptor(final Class<?> @Nullable ... parameterTypes) {
+        if (parameterTypes == null) {
+            // Null parameterTypes is treated as an empty array
+            return "()";
+        }
+        final StringBuilder builder = new StringBuilder();
+        builder.append('(');
+        for (final Class<?> parameterType : parameterTypes) {
+            builder.append(parameterType.descriptorString());
+        }
+        builder.append(')');
+        return builder.toString();
+    }
+
+    private static String removeCraftBukkitRelocation(final String name) {
+        if (MappingEnvironment.hasMappings()) {
+            // Relocation is applied in reobf, and when mappings are present they handle the relocation
+            return name;
+        }
+        if (name.startsWith(LEGACY_CB_PACKAGE_PREFIX)) {
+            return CB_PACKAGE_PREFIX + name.substring(LEGACY_CB_PACKAGE_PREFIX.length());
+        }
+        return name;
+    }
+
+    @Override
+    public Class<?> defineClass(final Object loader, final byte[] b, final int off, final int len) throws ClassFormatError {
+        return this.defineClassProxy.defineClass(loader, b, off, len);
+    }
+
+    @Override
+    public Class<?> defineClass(final Object loader, final String name, final byte[] b, final int off, final int len) throws ClassFormatError {
+        return this.defineClassProxy.defineClass(loader, name, b, off, len);
+    }
+
+    @Override
+    public Class<?> defineClass(final Object loader, final @Nullable String name, final byte[] b, final int off, final int len, final @Nullable ProtectionDomain protectionDomain) throws ClassFormatError {
+        return this.defineClassProxy.defineClass(loader, name, b, off, len, protectionDomain);
+    }
+
+    @Override
+    public Class<?> defineClass(final Object loader, final String name, final ByteBuffer b, final ProtectionDomain protectionDomain) throws ClassFormatError {
+        return this.defineClassProxy.defineClass(loader, name, b, protectionDomain);
+    }
+
+    @Override
+    public Class<?> defineClass(final Object secureLoader, final String name, final byte[] b, final int off, final int len, final CodeSource cs) {
+        return this.defineClassProxy.defineClass(secureLoader, name, b, off, len, cs);
+    }
+
+    @Override
+    public Class<?> defineClass(final Object secureLoader, final String name, final ByteBuffer b, final CodeSource cs) {
+        return this.defineClassProxy.defineClass(secureLoader, name, b, cs);
+    }
+
+    @Override
+    public Class<?> defineClass(final MethodHandles.Lookup lookup, final byte[] bytes) throws IllegalAccessException {
+        return this.defineClassProxy.defineClass(lookup, bytes);
+    }
+
+    // todo apply bytecode remap here as well
+    private static byte[] processClass(final byte[] bytes) {
+        try {
+            return ReflectionRemapper.processClass(bytes);
+        } catch (final Exception ex) {
+            LOGGER.warn("Failed to process class bytes", ex);
+            return bytes;
+        }
+    }
+}
diff --git a/src/main/java/io/papermc/paper/pluginremap/reflect/ReflectionRemapper.java b/src/main/java/io/papermc/paper/pluginremap/reflect/ReflectionRemapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..a3045afbc0cc057e99189b909367b21cf6a9e03f
--- /dev/null
+++ b/src/main/java/io/papermc/paper/pluginremap/reflect/ReflectionRemapper.java
@@ -0,0 +1,66 @@
+package io.papermc.paper.pluginremap.reflect;
+
+import io.papermc.asm.ClassInfoProvider;
+import io.papermc.asm.RewriteRuleVisitorFactory;
+import io.papermc.paper.util.MappingEnvironment;
+import io.papermc.reflectionrewriter.BaseReflectionRules;
+import io.papermc.reflectionrewriter.DefineClassRule;
+import io.papermc.reflectionrewriter.proxygenerator.ProxyGenerator;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Method;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.framework.qual.DefaultQualifier;
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+
+@DefaultQualifier(NonNull.class)
+public final class ReflectionRemapper {
+    private static final String PAPER_REFLECTION_HOLDER = "io.papermc.paper.pluginremap.reflect.PaperReflectionHolder";
+    private static final String PAPER_REFLECTION_HOLDER_DESC = PAPER_REFLECTION_HOLDER.replace('.', '/');
+    private static final RewriteRuleVisitorFactory VISITOR_FACTORY = RewriteRuleVisitorFactory.create(
+        Opcodes.ASM9,
+        chain -> chain.then(new BaseReflectionRules(PAPER_REFLECTION_HOLDER).rules())
+            .then(DefineClassRule.create(PAPER_REFLECTION_HOLDER_DESC, true)),
+        ClassInfoProvider.basic()
+    );
+
+    static {
+        if (!MappingEnvironment.reobf()) {
+            setupProxy();
+        }
+    }
+
+    private ReflectionRemapper() {
+    }
+
+    public static ClassVisitor visitor(final ClassVisitor parent) {
+        if (MappingEnvironment.reobf() || MappingEnvironment.DISABLE_PLUGIN_REMAPPING) {
+            return parent;
+        }
+        return VISITOR_FACTORY.createVisitor(parent);
+    }
+
+    public static byte[] processClass(final byte[] bytes) {
+        if (MappingEnvironment.DISABLE_PLUGIN_REMAPPING) {
+            return bytes;
+        }
+        final ClassReader classReader = new ClassReader(bytes);
+        final ClassWriter classWriter = new ClassWriter(classReader, 0);
+        classReader.accept(ReflectionRemapper.visitor(classWriter), 0);
+        return classWriter.toByteArray();
+    }
+
+    private static void setupProxy() {
+        try {
+            final byte[] bytes = ProxyGenerator.generateProxy(PaperReflection.class, PAPER_REFLECTION_HOLDER_DESC);
+            final MethodHandles.Lookup lookup = MethodHandles.lookup();
+            final Class<?> generated = lookup.defineClass(bytes);
+            final Method init = generated.getDeclaredMethod("init", PaperReflection.class);
+            init.invoke(null, new PaperReflection());
+        } catch (final ReflectiveOperationException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+}
diff --git a/src/main/java/io/papermc/paper/util/MappingEnvironment.java b/src/main/java/io/papermc/paper/util/MappingEnvironment.java
index 8e4229634d41a42b3d93948eebb77def7c0c72b1..4477944f632a6b3936960ee80f9d898d3b7eed19 100644
--- a/src/main/java/io/papermc/paper/util/MappingEnvironment.java
+++ b/src/main/java/io/papermc/paper/util/MappingEnvironment.java
@@ -10,6 +10,8 @@ import org.checkerframework.framework.qual.DefaultQualifier;
 
 @DefaultQualifier(NonNull.class)
 public final class MappingEnvironment {
+    public static final boolean DISABLE_PLUGIN_REMAPPING = Boolean.getBoolean("paper.disablePluginRemapping");
+    public static final String LEGACY_CB_VERSION = "v1_21_R2";
     private static final @Nullable String MAPPINGS_HASH = readMappingsHash();
     private static final boolean REOBF = checkReobf();
 
diff --git a/src/main/java/io/papermc/paper/util/StacktraceDeobfuscator.java b/src/main/java/io/papermc/paper/util/StacktraceDeobfuscator.java
index 242811578a786e3807a1a7019d472d5a68f87116..0b65fdf53124f3dd042b2363b1b8df8e1ca7de00 100644
--- a/src/main/java/io/papermc/paper/util/StacktraceDeobfuscator.java
+++ b/src/main/java/io/papermc/paper/util/StacktraceDeobfuscator.java
@@ -29,6 +29,9 @@ public enum StacktraceDeobfuscator {
     });
 
     public void deobfuscateThrowable(final Throwable throwable) {
+        if (!MappingEnvironment.reobf()) {
+            return;
+        }
         if (GlobalConfiguration.get() != null && !GlobalConfiguration.get().logging.deobfuscateStacktraces) { // handle null as true
             return;
         }
@@ -44,6 +47,9 @@ public enum StacktraceDeobfuscator {
     }
 
     public StackTraceElement[] deobfuscateStacktrace(final StackTraceElement[] traceElements) {
+        if (!MappingEnvironment.reobf()) {
+            return traceElements;
+        }
         if (GlobalConfiguration.get() != null && !GlobalConfiguration.get().logging.deobfuscateStacktraces) { // handle null as true
             return traceElements;
         }
diff --git a/src/main/java/org/bukkit/craftbukkit/util/Commodore.java b/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
index 2a29f60c3e82239ab7acd85242fc3390cb9129cd..91c6721201b095eb32c5fd5a1aaf2cbcf3ee196d 100644
--- a/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
+++ b/src/main/java/org/bukkit/craftbukkit/util/Commodore.java
@@ -126,36 +126,26 @@ public class Commodore {
     }
 
     // Paper start - Plugin rewrites
-    private static final Map<String, String> SEARCH_AND_REMOVE = initReplacementsMap();
-    private static Map<String, String> initReplacementsMap() {
-        Map<String, String> getAndRemove = new HashMap<>();
-        // Be wary of maven shade's relocations
-
-        final java.util.jar.Manifest manifest = io.papermc.paper.util.JarManifests.manifest(Commodore.class);
-        if (Boolean.getBoolean( "debug.rewriteForIde") && manifest != null)
-        {
-            // unversion incoming calls for pre-relocate debug work
-            final String NMS_REVISION_PACKAGE = "v" + manifest.getMainAttributes().getValue("CraftBukkit-Package-Version") + "/";
-
-            getAndRemove.put("org/bukkit/".concat("craftbukkit/" + NMS_REVISION_PACKAGE), NMS_REVISION_PACKAGE);
+    private static final String CB_PACKAGE_PREFIX = "org/bukkit/".concat("craftbukkit/");
+    private static final String LEGACY_CB_PACKAGE_PREFIX = CB_PACKAGE_PREFIX + io.papermc.paper.util.MappingEnvironment.LEGACY_CB_VERSION + "/";
+    private static String runtimeCbPkgPrefix() {
+        if (io.papermc.paper.util.MappingEnvironment.reobf()) {
+            return LEGACY_CB_PACKAGE_PREFIX;
         }
-
-        return getAndRemove;
+        return CB_PACKAGE_PREFIX;
     }
 
     @Nonnull
     private static String getOriginalOrRewrite(@Nonnull String original)
     {
-        String rewrite = null;
-        for ( Map.Entry<String, String> entry : SEARCH_AND_REMOVE.entrySet() )
-        {
-            if ( original.contains( entry.getKey() ) )
-            {
-                rewrite = original.replace( entry.getValue(), "" );
+        // Relocation is applied in reobf, and when mappings are present they handle the relocation
+        if (!io.papermc.paper.util.MappingEnvironment.reobf() && !io.papermc.paper.util.MappingEnvironment.hasMappings()) {
+            if (original.contains(LEGACY_CB_PACKAGE_PREFIX)) {
+                original = original.replace(LEGACY_CB_PACKAGE_PREFIX, CB_PACKAGE_PREFIX);
             }
         }
 
-        return rewrite != null ? rewrite : original;
+        return original;
     }
     // Paper end - Plugin rewrites
 
@@ -240,6 +230,7 @@ public class Commodore {
             visitor = new LimitedClassRemapper(cw, new SimpleRemapper(Commodore.ENUM_RENAMES));
         }
 
+        visitor = io.papermc.paper.pluginremap.reflect.ReflectionRemapper.visitor(visitor); // Paper
         cr.accept(new ClassRemapper(new ClassVisitor(Opcodes.ASM9, visitor) {
             final Set<RerouteMethodData> rerouteMethodData = new HashSet<>();
             String className;
diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
index 1aae364ee6c67b6c89a59ad6cab83bb921645453..a45c08c423248a60f9d5822046014427a6dadd12 100644
--- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
+++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
@@ -74,6 +74,7 @@ import org.bukkit.potion.PotionType;
 @SuppressWarnings("deprecation")
 public final class CraftMagicNumbers implements UnsafeValues {
     public static final CraftMagicNumbers INSTANCE = new CraftMagicNumbers();
+    public static final boolean DISABLE_OLD_API_SUPPORT = Boolean.getBoolean("paper.disableOldApiSupport"); // Paper
 
     private final Commodore commodore = new Commodore();
 
@@ -346,7 +347,7 @@ public final class CraftMagicNumbers implements UnsafeValues {
             throw new InvalidPluginException("Plugin API version " + pdf.getAPIVersion() + " is lower than the minimum allowed version. Please update or replace it.");
         }
 
-        if (toCheck.isOlderThan(ApiVersion.FLATTENING)) {
+        if (!DISABLE_OLD_API_SUPPORT && toCheck.isOlderThan(ApiVersion.FLATTENING)) { // Paper
             CraftLegacy.init();
         }
 
@@ -361,6 +362,12 @@ public final class CraftMagicNumbers implements UnsafeValues {
 
     @Override
     public byte[] processClass(PluginDescriptionFile pdf, String path, byte[] clazz) {
+        // Paper start
+        if (DISABLE_OLD_API_SUPPORT) {
+            // Make sure we still go through our reflection rewriting if needed
+            return io.papermc.paper.pluginremap.reflect.ReflectionRemapper.processClass(clazz);
+        }
+        // Paper end
         try {
             clazz = this.commodore.convert(clazz, pdf.getName(), ApiVersion.getOrCreateVersion(pdf.getAPIVersion()), ((CraftServer) Bukkit.getServer()).activeCompatibilities);
         } catch (Exception ex) {