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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
package cuchaz.enigma.gui;
import cuchaz.enigma.EnigmaProject;
import cuchaz.enigma.EnigmaServices;
import cuchaz.enigma.analysis.EntryReference;
import cuchaz.enigma.source.Token;
import cuchaz.enigma.api.service.NameProposalService;
import cuchaz.enigma.gui.highlight.TokenHighlightType;
import cuchaz.enigma.source.SourceIndex;
import cuchaz.enigma.source.SourceRemapper;
import cuchaz.enigma.translation.LocalNameGenerator;
import cuchaz.enigma.translation.Translator;
import cuchaz.enigma.translation.mapping.EntryRemapper;
import cuchaz.enigma.translation.mapping.ResolutionStrategy;
import cuchaz.enigma.translation.representation.TypeDescriptor;
import cuchaz.enigma.translation.representation.entry.ClassEntry;
import cuchaz.enigma.translation.representation.entry.Entry;
import cuchaz.enigma.translation.representation.entry.LocalVariableDefEntry;
import javax.annotation.Nullable;
import java.util.*;
public class DecompiledClassSource {
private final ClassEntry classEntry;
private final SourceIndex obfuscatedIndex;
private SourceIndex remappedIndex;
private final Map<TokenHighlightType, Collection<Token>> highlightedTokens = new EnumMap<>(TokenHighlightType.class);
public DecompiledClassSource(ClassEntry classEntry, SourceIndex index) {
this.classEntry = classEntry;
this.obfuscatedIndex = index;
this.remappedIndex = index;
}
public static DecompiledClassSource text(ClassEntry classEntry, String text) {
return new DecompiledClassSource(classEntry, new SourceIndex(text));
}
public void remapSource(EnigmaProject project, Translator translator) {
highlightedTokens.clear();
SourceRemapper remapper = new SourceRemapper(obfuscatedIndex.getSource(), obfuscatedIndex.referenceTokens());
SourceRemapper.Result remapResult = remapper.remap((token, movedToken) -> remapToken(project, token, movedToken, translator));
remappedIndex = obfuscatedIndex.remapTo(remapResult);
}
private String remapToken(EnigmaProject project, Token token, Token movedToken, Translator translator) {
EntryReference<Entry<?>, Entry<?>> reference = obfuscatedIndex.getReference(token);
Entry<?> entry = reference.getNameableEntry();
Entry<?> translatedEntry = translator.translate(entry);
if (project.isRenamable(reference)) {
if (isDeobfuscated(entry, translatedEntry)) {
highlightToken(movedToken, TokenHighlightType.DEOBFUSCATED);
return translatedEntry.getSourceRemapName();
} else {
Optional<String> proposedName = proposeName(project, entry);
if (proposedName.isPresent()) {
highlightToken(movedToken, TokenHighlightType.PROPOSED);
return proposedName.get();
}
highlightToken(movedToken, TokenHighlightType.OBFUSCATED);
}
}
String defaultName = generateDefaultName(translatedEntry);
if (defaultName != null) {
return defaultName;
}
return null;
}
private Optional<String> proposeName(EnigmaProject project, Entry<?> entry) {
EnigmaServices services = project.getEnigma().getServices();
return services.get(NameProposalService.TYPE).stream().flatMap(nameProposalService -> {
EntryRemapper mapper = project.getMapper();
Collection<Entry<?>> resolved = mapper.getObfResolver().resolveEntry(entry, ResolutionStrategy.RESOLVE_ROOT);
return resolved.stream()
.map(e -> nameProposalService.proposeName(e, mapper))
.filter(Optional::isPresent)
.map(Optional::get);
}).findFirst();
}
@Nullable
private String generateDefaultName(Entry<?> entry) {
if (entry instanceof LocalVariableDefEntry) {
LocalVariableDefEntry localVariable = (LocalVariableDefEntry) entry;
int index = localVariable.getIndex();
if (localVariable.isArgument()) {
List<TypeDescriptor> arguments = localVariable.getParent().getDesc().getArgumentDescs();
return LocalNameGenerator.generateArgumentName(index, localVariable.getDesc(), arguments);
} else {
return LocalNameGenerator.generateLocalVariableName(index, localVariable.getDesc());
}
}
return null;
}
private boolean isDeobfuscated(Entry<?> entry, Entry<?> translatedEntry) {
return !entry.getName().equals(translatedEntry.getName());
}
public ClassEntry getEntry() {
return classEntry;
}
public SourceIndex getIndex() {
return remappedIndex;
}
public Map<TokenHighlightType, Collection<Token>> getHighlightedTokens() {
return highlightedTokens;
}
private void highlightToken(Token token, TokenHighlightType highlightType) {
highlightedTokens.computeIfAbsent(highlightType, t -> new ArrayList<>()).add(token);
}
public int getObfuscatedOffset(int deobfOffset) {
return getOffset(remappedIndex, obfuscatedIndex, deobfOffset);
}
public int getDeobfuscatedOffset(int obfOffset) {
return getOffset(obfuscatedIndex, remappedIndex, obfOffset);
}
private static int getOffset(SourceIndex fromIndex, SourceIndex toIndex, int fromOffset) {
int relativeOffset = 0;
Iterator<Token> fromTokenItr = fromIndex.referenceTokens().iterator();
Iterator<Token> toTokenItr = toIndex.referenceTokens().iterator();
while (fromTokenItr.hasNext() && toTokenItr.hasNext()) {
Token fromToken = fromTokenItr.next();
Token toToken = toTokenItr.next();
if (fromToken.end > fromOffset) {
break;
}
relativeOffset = toToken.end - fromToken.end;
}
return fromOffset + relativeOffset;
}
@Override
public String toString() {
return remappedIndex.getSource();
}
}
|
