private Accessor<ObjectType,FieldType> getDeobfuscated(ObjectType objectType) { Class objectClass = objectType.getClass(); Set<String> obfedClasses = FMLDeobfuscatingRemapper.INSTANCE.getObfedClasses(); for (String readableName: obfedClasses) { String obfedName = FMLDeobfuscatingRemapper.INSTANCE.map(readableName); logger.info(readableName+" to "+obfedName); remapper = FMLDeobfuscatingRemapper.INSTANCE; Map<String,String> fieldMap = this.fieldAccessor.get(remapper).get(readableName); if (fieldMap== null) continue; for (String key: fieldMap.keySet()) { logger.info(" "+key + " " + fieldMap.get(key)); } } while ((objectClass != null)&&(objectClass != Object.class)) { String deobfuscatedClassName = FMLDeobfuscatingRemapper.INSTANCE.unmap(objectClass.getCanonicalName()); if (deobfuscatedClassName == null) continue; if (deobfuscatedClassName.equals("")) continue; deobfuscatedName = FMLDeobfuscatingRemapper.INSTANCE.mapFieldName(deobfuscatedClassName, fieldName, fieldName); deobfuscated = new Accessor<ObjectType,FieldType>(deobfuscatedName); } throw new RuntimeException("Could not remap field "+fieldName+ " in class "+objectType.getClass().getCanonicalName()); }
public static BlockMatcher parse(String s) throws Exception { if (s.startsWith(BaMsConfig.CLASS_PREFIX)) { String className = s.substring(BaMsConfig.CLASS_PREFIX.length()); className = FMLDeobfuscatingRemapper.INSTANCE.map(className).replace('/', '.'); return new BlockMatcher(Class.forName(className)); } ResourceLocation name = new ResourceLocation(s); if (BaMsConfig.ORE_DICT_ID.equals(name.getResourceDomain())) { return new BlockMatcher(name.getResourcePath()); } IBlockState state = BlockHelper.parseBlockState(s); if (state != null) { return new BlockMatcher(state); } return null; }
@Override public void injectData(Map<String, Object> data) { liveEnv = (Boolean)data.get("runtimeDeobfuscationEnabled"); cl = (LaunchClassLoader) data.get("classLoader"); File mcDir = (File)data.get("mcLocation"); fmlLocation = (File)data.get("coremodLocation"); ClassPatchManager.INSTANCE.setup(FMLLaunchHandler.side()); FMLDeobfuscatingRemapper.INSTANCE.setup(mcDir, cl, (String) data.get("deobfuscationFileName")); }
public static String[] remapFieldNames(String className, String... fieldNames) { String internalClassName = FMLDeobfuscatingRemapper.INSTANCE.unmap(className.replace('.', '/')); String[] mappedNames = new String[fieldNames.length]; int i = 0; for (String fName : fieldNames) { mappedNames[i++] = FMLDeobfuscatingRemapper.INSTANCE.mapFieldName(internalClassName, fName, null); } return mappedNames; }
private static String getMethodName(String context, String name, String desc) { String deobf = FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(context, name, desc); // do further tweaks to the name for methods that aren't fully deobfuscated by FML for (int i = 0; i < methodAltNames.length; i++) { if (methodAltNames[i++].equals(deobf)) { // steps through list two at a time. deobf = methodAltNames[i]; // this is now the second of the pair. break; } } // may be the original name if neither FML nor we had any data. return deobf; }
/** * Return true if method matches * * @param methodName * @param methodDescription * @return true or false if not match */ public boolean match(String methodName, String methodDescription) { if (!methodDescription.equals(methodDescription)) return false; if (methodName.equals(methodMcpName)) return true; if (!ASMUtil.useSrgNames()) return false; String mapped = FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(clazzName, methodName, methodDescription); return mapped.equals(methodSrgName); }
public boolean match(String methodName, String methodDesc) { if (!methodDesc.equals(description)) return false; if (methodName.equals(mcpName)) return true; if (!ReflectionUtil.useSrgNames()) return false; String mapped = FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(clsName, methodName, methodDesc); return mapped.equals(srgName); }
public boolean match(String fieldName, String fieldDesc) { if (!fieldDesc.equals(description)) return false; if (fieldName.equals(mcpName)) return true; if (!ReflectionUtil.useSrgNames()) return false; String mapped = FMLDeobfuscatingRemapper.INSTANCE.mapFieldName(clsName, fieldName, fieldDesc); return mapped.equals(srgName); }
boolean applies(MethodNode method) { if (LoadingPlugin.deobfuscatedEnvironment) { return method.name.equals(mcpName); } else { String method_as_srg = FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(obfClassName, method.name, method.desc); return srgName.equals(method_as_srg); } }
public MutateCall setOwner(String owner) { this.find_mcp_owner = owner.replace(".", "/"); if (!ASMTransformer.dev_environ) { owner = FMLDeobfuscatingRemapper.INSTANCE.unmap(find_mcp_owner); } this.find_notch_owner = owner.replace(".", "/"); return this; }
public static String getSuperClass(String name, boolean runtime) { name = toKey(name); SuperCache cache = declareClass(name); if (cache == null) { return "java.lang.Object"; } cache.flatten(); String s = cache.superclass; if (!runtime) { s = FMLDeobfuscatingRemapper.INSTANCE.unmap(s); } return s; }
public boolean match(String methodName, String methodDesc) { if (!methodDesc.equals(description)) return false; if (methodName.equals(mcpName)) return true; if (!VisitorHelper.useSrgNames()) return false; String mapped = FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(clsName, methodName, methodDesc); return mapped.equals(srgName); }
public boolean match(String fieldName, String fieldDesc) { if (!fieldDesc.equals(description)) return false; if (fieldName.equals(mcpName)) return true; if (!VisitorHelper.useSrgNames()) return false; String mapped = FMLDeobfuscatingRemapper.INSTANCE.mapFieldName(clsName, fieldName, fieldDesc); return mapped.equals(srgName); }
protected ObfuscatedStateMapper() { LOGGER.info("Using build mapping \"" + ForgeHaxProperties.getMcpMappingUrl() + "\""); MCPMappingLoader mcpMappingLoader = null; try { mcpMappingLoader = new MCPMappingLoader(ForgeHaxProperties.getMcpMappingUrl()); } catch (Exception e) { LOGGER.error(e.getMessage()); ASMStackLogger.printStackTrace(e); } LOGGER.info("Mapping data successfully initialize"); Objects.requireNonNull(mcpMappingLoader, "MCPMappingLoader failed to lookup obfuscation data"); if(isObfuscated()) LOGGER.info("initializing ObfuscatedStateMapper WITH obfuscation"); else LOGGER.info("initializing ObfuscatedStateMapper WITHOUT obfuscation"); this.mcClasses = ImmutableBiMap.copyOf(FastReflectionForge.Fields.FMLDeobfuscatingRemapper_classNameBiMap.get(FMLDeobfuscatingRemapper.INSTANCE)); this.mcpMethodData = buildMcpTypeData( mcpMappingLoader.getCsvMethodData(), mcpMappingLoader.getSrgFileData().class2MethodDataSet, getConvertedMap( FastReflectionForge.Fields.FMLDeobfuscatingRemapper_rawMethodMaps.get(FMLDeobfuscatingRemapper.INSTANCE), str -> str.split("\\(")[0] ), ((csvData, data) -> csvData.getMcpName() + data.getSrgDescriptor()) ); this.mcpFieldData = buildMcpTypeData( mcpMappingLoader.getCsvFieldData(), mcpMappingLoader.getSrgFileData().class2FieldDataSet, getConvertedMap( FastReflectionForge.Fields.FMLDeobfuscatingRemapper_rawFieldMaps.get(FMLDeobfuscatingRemapper.INSTANCE), str -> str.split(":")[0] ), ((csvData, data) -> csvData.getMcpName()) ); }
public static void main(String[] args) throws IOException { String sourceJar = args[0]; //Clean Vanilla jar minecraft.jar or minecraft_server.jar String targetDir = args[1]; //Directory containing obfed output classes, typically mcp/reobf/minecraft String deobfData = args[2]; //Path to FML's deobfusication_data.lzma String outputDir = args[3]; //Path to place generated .binpatch String killTarget = args[4]; //"true" if we should destroy the target file if it generated a successful .binpatch LogManager.getLogger("GENDIFF").log(Level.INFO, String.format("Creating patches at %s for %s from %s", outputDir, sourceJar, targetDir)); Delta delta = new Delta(); FMLDeobfuscatingRemapper remapper = FMLDeobfuscatingRemapper.INSTANCE; remapper.setupLoadOnly(deobfData, false); JarFile sourceZip = new JarFile(sourceJar); boolean kill = killTarget.equalsIgnoreCase("true"); File f = new File(outputDir); f.mkdirs(); for (String name : remapper.getObfedClasses()) { // Logger.getLogger("GENDIFF").info(String.format("Evaluating path for data :%s",name)); String fileName = name; String jarName = name; if (RESERVED_NAMES.contains(name.toUpperCase(Locale.ENGLISH))) { fileName = "_"+name; } File targetFile = new File(targetDir, fileName.replace('/', File.separatorChar) + ".class"); jarName = jarName+".class"; if (targetFile.exists()) { String sourceClassName = name.replace('/', '.'); String targetClassName = remapper.map(name).replace('/', '.'); JarEntry entry = sourceZip.getJarEntry(jarName); byte[] vanillaBytes = toByteArray(sourceZip, entry); byte[] patchedBytes = Files.toByteArray(targetFile); byte[] diff = delta.compute(vanillaBytes, patchedBytes); ByteArrayDataOutput diffOut = ByteStreams.newDataOutput(diff.length + 50); // Original name diffOut.writeUTF(name); // Source name diffOut.writeUTF(sourceClassName); // Target name diffOut.writeUTF(targetClassName); // exists at original diffOut.writeBoolean(entry != null); if (entry != null) { diffOut.writeInt(Hashing.adler32().hashBytes(vanillaBytes).asInt()); } // length of patch diffOut.writeInt(diff.length); // patch diffOut.write(diff); File target = new File(outputDir, targetClassName+".binpatch"); target.getParentFile().mkdirs(); Files.write(diffOut.toByteArray(), target); Logger.getLogger("GENDIFF").info(String.format("Wrote patch for %s (%s) at %s",name, targetClassName, target.getAbsolutePath())); if (kill) { targetFile.delete(); Logger.getLogger("GENDIFF").info(String.format(" Deleted target: %s", targetFile.toString())); } } } sourceZip.close(); }
@Override public String remapClassName(String name) { return FMLDeobfuscatingRemapper.INSTANCE.map(name.replace('.','/')).replace('/', '.'); }
@Override public String unmapClassName(String name) { return FMLDeobfuscatingRemapper.INSTANCE.unmap(name.replace('.', '/')).replace('/','.'); }
private static String descClass(String name) { if (isObfuscated) { return "L" + FMLDeobfuscatingRemapper.INSTANCE.unmap(name.replace(".", "/")) + ";"; } return "L" + name.replace(".", "/") + ";"; }
@Override public String map(String typeName) { return FMLDeobfuscatingRemapper.INSTANCE.unmap(typeName); }
public static String getMappedName(String clsName) { return ReflectionUtil.useSrgNames() ? FMLDeobfuscatingRemapper.INSTANCE.unmap(clsName) : clsName; }
@Override public String unmapType(String typeName) { return FMLDeobfuscatingRemapper.INSTANCE.unmap(typeName); }
@Override public String mapType(String typeName) { return FMLDeobfuscatingRemapper.INSTANCE.map(typeName); }
@Override public String mapMethodName(String owner, String name, String desc) { return FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(owner.replace('.', '/'), name, desc); }
@Override public String mapFieldName(String owner, String name, String desc) { return FMLDeobfuscatingRemapper.INSTANCE.mapFieldName(owner.replace('.', '/'), name, desc); }
/** * Deobfuscates an obfuscated class name regardless of {@link #isObfuscated()}. */ public static String forceToDeobfClassName(String obfClassName) { return FMLDeobfuscatingRemapper.INSTANCE.map(obfClassName.replace('.', '/')).replace('/', '.'); }
/** * Obfuscates a deobfuscated class name regardless of {@link #isObfuscated()}. */ public static String forceToObfClassName(String deobfClassName) { return FMLDeobfuscatingRemapper.INSTANCE.unmap(deobfClassName.replace('.', '/')).replace('/', '.'); }
public static String toKey(String name) { if (ObfMapping.obfuscated) { name = FMLDeobfuscatingRemapper.INSTANCE.map(name.replace('.', '/')).replace('/', '.'); } return name; }
public static String unKey(String name) { if (ObfMapping.obfuscated) { name = FMLDeobfuscatingRemapper.INSTANCE.unmap(name.replace('.', '/')).replace('/', '.'); } return name; }
public static String getClassFor(String name) { return FMLDeobfuscatingRemapper.INSTANCE.unmap(name.replace("/", ".")).replace('.', '/'); }
public static String getSRGDescriptor(String signature) { return FMLDeobfuscatingRemapper.INSTANCE.mapMethodDesc(signature); }
public static String getSrgName(MethodInsnNode node) { return IvDevRemapper.getSRGName(FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(node.owner, node.name, node.desc)); }
public static String getSrgName(String className, MethodNode node) { return IvDevRemapper.getSRGName(FMLDeobfuscatingRemapper.INSTANCE.mapMethodName(className, node.name, node.desc)); }
public static String getSrgName(FieldInsnNode node) { return IvDevRemapper.getSRGName(FMLDeobfuscatingRemapper.INSTANCE.mapFieldName(node.owner, node.name, node.desc)); }
public static String getSrgClassName(String className) { return FMLDeobfuscatingRemapper.INSTANCE.map(className); }
public static String getMappedName(String clsName) { return useSrgNames()? FMLDeobfuscatingRemapper.INSTANCE.unmap(clsName) : clsName; }
/** * Get right maptype * * @param clsName * classname * @return maptype */ public static String getMappedName(String clsName) { return useSrgNames() ? FMLDeobfuscatingRemapper.INSTANCE.unmap(clsName) : clsName; }
public String unmap(String typeName) { return FMLDeobfuscatingRemapper.INSTANCE.map(typeName); }