1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
package cuchaz.enigma.translation.mapping;
import cuchaz.enigma.analysis.index.JarIndex;
import cuchaz.enigma.translation.MappingTranslator;
import cuchaz.enigma.translation.Translatable;
import cuchaz.enigma.translation.Translator;
import cuchaz.enigma.translation.mapping.tree.DeltaTrackingTree;
import cuchaz.enigma.translation.mapping.tree.EntryTree;
import cuchaz.enigma.translation.mapping.tree.HashEntryTree;
import cuchaz.enigma.translation.representation.entry.Entry;
import javax.annotation.Nullable;
import java.util.Collection;
import java.util.stream.Stream;
public class EntryRemapper {
private final DeltaTrackingTree<EntryMapping> obfToDeobf;
private final EntryResolver obfResolver;
private final Translator deobfuscator;
private final MappingValidator validator;
private EntryRemapper(JarIndex jarIndex, EntryTree<EntryMapping> obfToDeobf) {
this.obfToDeobf = new DeltaTrackingTree<>(obfToDeobf);
this.obfResolver = jarIndex.getEntryResolver();
this.deobfuscator = new MappingTranslator(obfToDeobf, obfResolver);
this.validator = new MappingValidator(obfToDeobf, deobfuscator, jarIndex);
}
public static EntryRemapper mapped(JarIndex index, EntryTree<EntryMapping> obfToDeobf) {
return new EntryRemapper(index, obfToDeobf);
}
public static EntryRemapper empty(JarIndex index) {
return new EntryRemapper(index, new HashEntryTree<>());
}
public <E extends Entry<?>> void mapFromObf(E obfuscatedEntry, @Nullable EntryMapping deobfMapping) {
Collection<E> resolvedEntries = obfResolver.resolveEntry(obfuscatedEntry, ResolutionStrategy.RESOLVE_ROOT);
if (deobfMapping != null) {
for (E resolvedEntry : resolvedEntries) {
validator.validateRename(resolvedEntry, deobfMapping.getTargetName());
}
}
for (E resolvedEntry : resolvedEntries) {
obfToDeobf.insert(resolvedEntry, deobfMapping);
}
}
public void removeByObf(Entry<?> obfuscatedEntry) {
mapFromObf(obfuscatedEntry, null);
}
@Nullable
public EntryMapping getDeobfMapping(Entry<?> entry) {
return obfToDeobf.get(entry);
}
public boolean hasDeobfMapping(Entry<?> obfEntry) {
return obfToDeobf.contains(obfEntry);
}
public <T extends Translatable> T deobfuscate(T translatable) {
return deobfuscator.translate(translatable);
}
public Translator getDeobfuscator() {
return deobfuscator;
}
public Stream<Entry<?>> getObfEntries() {
return obfToDeobf.getAllEntries();
}
public Collection<Entry<?>> getObfChildren(Entry<?> obfuscatedEntry) {
return obfToDeobf.getChildren(obfuscatedEntry);
}
public DeltaTrackingTree<EntryMapping> getObfToDeobf() {
return obfToDeobf;
}
public MappingDelta<EntryMapping> takeMappingDelta() {
return obfToDeobf.takeDelta();
}
public boolean isDirty() {
return obfToDeobf.isDirty();
}
public EntryResolver getObfResolver() {
return obfResolver;
}
}
|
