/*
* ProGuard -- shrinking, optimization, obfuscation, and preverification
* of Java bytecode.
*
* Copyright (c) 2002-2017 Eric Lafortune @ GuardSquare
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package proguard.retrace;
import proguard.obfuscate.MappingProcessor;
import java.util.*;
/**
* This class accumulates mapping information and then transforms stack frames
* accordingly.
*
* @author Eric Lafortune
*/
public class FrameRemapper implements MappingProcessor
{
// Obfuscated class name -> original class name.
private final Map<String,String> classMap = new HashMap<String,String>();
// Original class name -> obfuscated member name -> member info set.
private final Map<String,Map<String,Set<FieldInfo>>> classFieldMap = new HashMap<String,Map<String,Set<FieldInfo>>>();
private final Map<String,Map<String,Set<MethodInfo>>> classMethodMap = new HashMap<String,Map<String,Set<MethodInfo>>>();
/**
* Transforms the given obfuscated frame back to one or more original frames.
*/
public List<FrameInfo> transform(FrameInfo obfuscatedFrame)
{
// First remap the class name.
String originalClassName = originalClassName(obfuscatedFrame.getClassName());
if (originalClassName == null)
{
return null;
}
List<FrameInfo> originalFrames = new ArrayList<FrameInfo>();
// Create any transformed frames with remapped field names.
transformFieldInfo(obfuscatedFrame,
originalClassName,
originalFrames);
// Create any transformed frames with remapped method names.
transformMethodInfo(obfuscatedFrame,
originalClassName,
originalFrames);
if (originalFrames.isEmpty())
{
// Create a transformed frame with the remapped class name.
originalFrames.add(new FrameInfo(originalClassName,
sourceFileName(originalClassName),
obfuscatedFrame.getLineNumber(),
obfuscatedFrame.getType(),
obfuscatedFrame.getFieldName(),
obfuscatedFrame.getMethodName(),
obfuscatedFrame.getArguments()));
}
return originalFrames;
}
/**
* Transforms the obfuscated frame into one or more original frames,
* if the frame contains information about a field that can be remapped.
* @param obfuscatedFrame the obfuscated frame.
* @param originalFieldFrames the list in which remapped frames can be
* collected.
*/
private void transformFieldInfo(FrameInfo obfuscatedFrame,
String originalClassName,
List<FrameInfo> originalFieldFrames)
{
// Class name -> obfuscated field names.
Map<String,Set<FieldInfo>> fieldMap = classFieldMap.get(originalClassName);
if (fieldMap != null)
{
// Obfuscated field names -> fields.
String obfuscatedFieldName = obfuscatedFrame.getFieldName();
Set<FieldInfo> fieldSet = fieldMap.get(obfuscatedFieldName);
if (fieldSet != null)
{
String obfuscatedType = obfuscatedFrame.getType();
String originalType = obfuscatedType == null ? null :
originalType(obfuscatedType);
// Find all matching fields.
Iterator<FieldInfo> fieldInfoIterator = fieldSet.iterator();
while (fieldInfoIterator.hasNext())
{
FieldInfo fieldInfo = fieldInfoIterator.next();
if (fieldInfo.matches(originalType))
{
originalFieldFrames.add(new FrameInfo(fieldInfo.originalClassName,
sourceFileName(fieldInfo.originalClassName),
obfuscatedFrame.getLineNumber(),
fieldInfo.originalType,
fieldInfo.originalName,
obfuscatedFrame.getMethodName(),
obfuscatedFrame.getArguments()));
}
}
}
}
}
/**
* Transforms the obfuscated frame into one or more original frames,
* if the frame contains information about a method that can be remapped.
* @param obfuscatedFrame the obfuscated frame.
* @param originalMethodFrames the list in which remapped frames can be
* collected.
*/
private void transformMethodInfo(FrameInfo obfuscatedFrame,
String originalClassName,
List<FrameInfo> originalMethodFrames)
{
// Class name -> obfuscated method names.
Map<String,Set<MethodInfo>> methodMap = classMethodMap.get(originalClassName);
if (methodMap != null)
{
// Obfuscated method names -> methods.
String obfuscatedMethodName = obfuscatedFrame.getMethodName();
Set<MethodInfo> methodSet = methodMap.get(obfuscatedMethodName);
if (methodSet != null)
{
int obfuscatedLineNumber = obfuscatedFrame.getLineNumber();
String obfuscatedType = obfuscatedFrame.getType();
String originalType = obfuscatedType == null ? null :
originalType(obfuscatedType);
String obfuscatedArguments = obfuscatedFrame.getArguments();
String originalArguments = obfuscatedArguments == null ? null :
originalArguments(obfuscatedArguments);
// Find all matching methods.
Iterator<MethodInfo> methodInfoIterator = methodSet.iterator();
while (methodInfoIterator.hasNext())
{
MethodInfo methodInfo = methodInfoIterator.next();
if (methodInfo.matches(obfuscatedLineNumber,
originalType,
originalArguments))
{
// Do we have a different original first line number?
// We're allowing unknown values, represented as 0.
int lineNumber = obfuscatedFrame.getLineNumber();
if (methodInfo.originalFirstLineNumber != methodInfo.obfuscatedFirstLineNumber)
{
// Do we have an original line number range and
// sufficient information to shift the line number?
lineNumber = methodInfo.originalLastLineNumber != 0 &&
methodInfo.originalLastLineNumber != methodInfo.originalFirstLineNumber &&
methodInfo.obfuscatedFirstLineNumber != 0 &&
lineNumber != 0 ?
methodInfo.originalFirstLineNumber - methodInfo.obfuscatedFirstLineNumber + lineNumber :
methodInfo.originalFirstLineNumber;
}
originalMethodFrames.add(new FrameInfo(methodInfo.originalClassName,
sourceFileName(methodInfo.originalClassName),
lineNumber,
methodInfo.originalType,
obfuscatedFrame.getFieldName(),
methodInfo.originalName,
methodInfo.originalArguments));
}
}
}
}
}
/**
* Returns the original argument types.
*/
private String originalArguments(String obfuscatedArguments)
{
StringBuilder originalArguments = new StringBuilder();
int startIndex = 0;
while (true)
{
int endIndex = obfuscatedArguments.indexOf(',', startIndex);
if (endIndex < 0)
{
break;
}
originalArguments.append(originalType(obfuscatedArguments.substring(startIndex, endIndex).trim())).append(',');
startIndex = endIndex + 1;
}
originalArguments.append(originalType(obfuscatedArguments.substring(startIndex).trim()));
return originalArguments.toString();
}
/**
* Returns the original type.
*/
private String originalType(String obfuscatedType)
{
int index = obfuscatedType.indexOf('[');
return index >= 0 ?
originalClassName(obfuscatedType.substring(0, index)) + obfuscatedType.substring(index) :
originalClassName(obfuscatedType);
}
/**
* Returns the original class name.
*/
private String originalClassName(String obfuscatedClassName)
{
String originalClassName = classMap.get(obfuscatedClassName);
return originalClassName != null ?
originalClassName :
obfuscatedClassName;
}
/**
* Returns the Java source file name that typically corresponds to the
* given class name.
*/
private String sourceFileName(String className)
{
int index1 = className.lastIndexOf('.') + 1;
int index2 = className.indexOf('$', index1);
return (index2 > 0 ?
className.substring(index1, index2) :
className.substring(index1)) +
".java";
}
// Implementations for MappingProcessor.
public boolean processClassMapping(String className,
String newClassName)
{
// Obfuscated class name -> original class name.
classMap.put(newClassName, className);
return true;
}
public void processFieldMapping(String className,
String fieldType,
String fieldName,
String newClassName,
String newFieldName)
{
// Obfuscated class name -> obfuscated field names.
Map<String,Set<FieldInfo>> fieldMap = classFieldMap.get(newClassName);
if (fieldMap == null)
{
fieldMap = new HashMap<String,Set<FieldInfo>>();
classFieldMap.put(newClassName, fieldMap);
}
// Obfuscated field name -> fields.
Set<FieldInfo> fieldSet = fieldMap.get(newFieldName);
if (fieldSet == null)
{
fieldSet = new LinkedHashSet<FieldInfo>();
fieldMap.put(newFieldName, fieldSet);
}
// Add the field information.
fieldSet.add(new FieldInfo(className,
fieldType,
fieldName));
}
public void processMethodMapping(String className,
int firstLineNumber,
int lastLineNumber,
String methodReturnType,
String methodName,
String methodArguments,
String newClassName,
int newFirstLineNumber,
int newLastLineNumber,
String newMethodName)
{
// Original class name -> obfuscated method names.
Map<String,Set<MethodInfo>> methodMap = classMethodMap.get(newClassName);
if (methodMap == null)
{
methodMap = new HashMap<String,Set<MethodInfo>>();
classMethodMap.put(newClassName, methodMap);
}
// Obfuscated method name -> methods.
Set<MethodInfo> methodSet = methodMap.get(newMethodName);
if (methodSet == null)
{
methodSet = new LinkedHashSet<MethodInfo>();
methodMap.put(newMethodName, methodSet);
}
// Add the method information.
methodSet.add(new MethodInfo(newFirstLineNumber,
newLastLineNumber,
className,
firstLineNumber,
lastLineNumber,
methodReturnType,
methodName,
methodArguments));
}
/**
* Information about the original version and the obfuscated version of
* a field (without the obfuscated class name or field name).
*/
private static class FieldInfo
{
private final String originalClassName;
private final String originalType;
private final String originalName;
/**
* Creates a new FieldInfo with the given properties.
*/
private FieldInfo(String originalClassName,
String originalType,
String originalName)
{
this.originalClassName = originalClassName;
this.originalType = originalType;
this.originalName = originalName;
}
/**
* Returns whether the given type matches the original type of this field.
* The given type may be a null wildcard.
*/
private boolean matches(String originalType)
{
return
originalType == null || originalType.equals(this.originalType);
}
}
/**
* Information about the original version and the obfuscated version of
* a method (without the obfuscated class name or method name).
*/
private static class MethodInfo
{
private final int obfuscatedFirstLineNumber;
private final int obfuscatedLastLineNumber;
private final String originalClassName;
private final int originalFirstLineNumber;
private final int originalLastLineNumber;
private final String originalType;
private final String originalName;
private final String originalArguments;
/**
* Creates a new MethodInfo with the given properties.
*/
private MethodInfo(int obfuscatedFirstLineNumber,
int obfuscatedLastLineNumber,
String originalClassName,
int originalFirstLineNumber,
int originalLastLineNumber,
String originalType,
String originalName,
String originalArguments)
{
this.obfuscatedFirstLineNumber = obfuscatedFirstLineNumber;
this.obfuscatedLastLineNumber = obfuscatedLastLineNumber;
this.originalType = originalType;
this.originalArguments = originalArguments;
this.originalClassName = originalClassName;
this.originalName = originalName;
this.originalFirstLineNumber = originalFirstLineNumber;
this.originalLastLineNumber = originalLastLineNumber;
}
/**
* Returns whether the given properties match the properties of this
* method. The given properties may be null wildcards.
*/
private boolean matches(int obfuscatedLineNumber,
String originalType,
String originalArguments)
{
return
(obfuscatedLineNumber == 0 ? obfuscatedLastLineNumber == 0 :
obfuscatedFirstLineNumber <= obfuscatedLineNumber && obfuscatedLineNumber <= obfuscatedLastLineNumber) &&
(originalType == null || originalType.equals(this.originalType)) &&
(originalArguments == null || originalArguments.equals(this.originalArguments));
}
}
}