CrackMe.apk
Download file
package com.google.common.base;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import javax.annotation.CheckForNull;
@ElementTypesAreNonnullByDefault
public final class Throwables {
private static final String JAVA_LANG_ACCESS_CLASSNAME = "sun.misc.JavaLangAccess";
static final String SHARED_SECRETS_CLASSNAME = "sun.misc.SharedSecrets";
/* access modifiers changed from: private */
@CheckForNull
public static final Method getStackTraceDepthMethod;
/* access modifiers changed from: private */
@CheckForNull
public static final Method getStackTraceElementMethod;
/* access modifiers changed from: private */
@CheckForNull
public static final Object jla;
private Throwables() {
}
public static <X extends Throwable> void throwIfInstanceOf(Throwable th, Class<X> cls) throws Throwable {
Preconditions.checkNotNull(th);
if (cls.isInstance(th)) {
throw ((Throwable) cls.cast(th));
}
}
@Deprecated
public static <X extends Throwable> void propagateIfInstanceOf(@CheckForNull Throwable th, Class<X> cls) throws Throwable {
if (th != null) {
throwIfInstanceOf(th, cls);
}
}
public static void throwIfUnchecked(Throwable th) {
Preconditions.checkNotNull(th);
if (th instanceof RuntimeException) {
throw ((RuntimeException) th);
} else if (th instanceof Error) {
throw ((Error) th);
}
}
@Deprecated
public static void propagateIfPossible(@CheckForNull Throwable th) {
if (th != null) {
throwIfUnchecked(th);
}
}
public static <X extends Throwable> void propagateIfPossible(@CheckForNull Throwable th, Class<X> cls) throws Throwable {
propagateIfInstanceOf(th, cls);
propagateIfPossible(th);
}
public static <X1 extends Throwable, X2 extends Throwable> void propagateIfPossible(@CheckForNull Throwable th, Class<X1> cls, Class<X2> cls2) throws Throwable, Throwable {
Preconditions.checkNotNull(cls2);
propagateIfInstanceOf(th, cls);
propagateIfPossible(th, cls2);
}
@Deprecated
public static RuntimeException propagate(Throwable th) {
throwIfUnchecked(th);
throw new RuntimeException(th);
}
public static Throwable getRootCause(Throwable th) {
boolean z = false;
Throwable th2 = th;
while (true) {
Throwable cause = th.getCause();
if (cause == null) {
return th;
}
if (cause != th2) {
if (z) {
th2 = th2.getCause();
}
z = !z;
th = cause;
} else {
throw new IllegalArgumentException("Loop in causal chain detected.", cause);
}
}
}
public static List<Throwable> getCausalChain(Throwable th) {
Preconditions.checkNotNull(th);
ArrayList arrayList = new ArrayList(4);
arrayList.add(th);
boolean z = false;
Throwable th2 = th;
while (true) {
th = th.getCause();
if (th == null) {
return Collections.unmodifiableList(arrayList);
}
arrayList.add(th);
if (th != th2) {
if (z) {
th2 = th2.getCause();
}
z = !z;
} else {
throw new IllegalArgumentException("Loop in causal chain detected.", th);
}
}
}
@CheckForNull
public static <X extends Throwable> X getCauseAs(Throwable th, Class<X> cls) {
try {
return (Throwable) cls.cast(th.getCause());
} catch (ClassCastException e) {
e.initCause(th);
throw e;
}
}
public static String getStackTraceAsString(Throwable th) {
StringWriter stringWriter = new StringWriter();
th.printStackTrace(new PrintWriter(stringWriter));
return stringWriter.toString();
}
public static List<StackTraceElement> lazyStackTrace(Throwable th) {
if (lazyStackTraceIsLazy()) {
return jlaStackTrace(th);
}
return Collections.unmodifiableList(Arrays.asList(th.getStackTrace()));
}
public static boolean lazyStackTraceIsLazy() {
return (getStackTraceElementMethod == null || getStackTraceDepthMethod == null) ? false : true;
}
private static List<StackTraceElement> jlaStackTrace(final Throwable th) {
Preconditions.checkNotNull(th);
return new AbstractList<StackTraceElement>() {
public StackTraceElement get(int i) {
Method access$000 = Throwables.getStackTraceElementMethod;
Objects.requireNonNull(access$000);
Method method = access$000;
Object access$100 = Throwables.jla;
Objects.requireNonNull(access$100);
return (StackTraceElement) Throwables.invokeAccessibleNonThrowingMethod(access$000, access$100, th, Integer.valueOf(i));
}
public int size() {
Method access$300 = Throwables.getStackTraceDepthMethod;
Objects.requireNonNull(access$300);
Method method = access$300;
Object access$100 = Throwables.jla;
Objects.requireNonNull(access$100);
return ((Integer) Throwables.invokeAccessibleNonThrowingMethod(access$300, access$100, th)).intValue();
}
};
}
/* access modifiers changed from: private */
public static Object invokeAccessibleNonThrowingMethod(Method method, Object obj, Object... objArr) {
try {
return method.invoke(obj, objArr);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e2) {
throw propagate(e2.getCause());
}
}
static {
Method method;
Object jla2 = getJLA();
jla = jla2;
Method method2 = null;
if (jla2 == null) {
method = null;
} else {
method = getGetMethod();
}
getStackTraceElementMethod = method;
if (jla2 != null) {
method2 = getSizeMethod(jla2);
}
getStackTraceDepthMethod = method2;
}
@CheckForNull
private static Object getJLA() {
try {
return Class.forName(SHARED_SECRETS_CLASSNAME, false, (ClassLoader) null).getMethod("getJavaLangAccess", new Class[0]).invoke((Object) null, new Object[0]);
} catch (ThreadDeath e) {
throw e;
} catch (Throwable unused) {
return null;
}
}
@CheckForNull
private static Method getGetMethod() {
return getJlaMethod("getStackTraceElement", Throwable.class, Integer.TYPE);
}
@CheckForNull
private static Method getSizeMethod(Object obj) {
try {
Method jlaMethod = getJlaMethod("getStackTraceDepth", Throwable.class);
if (jlaMethod == null) {
return null;
}
jlaMethod.invoke(obj, new Object[]{new Throwable()});
return jlaMethod;
} catch (IllegalAccessException | UnsupportedOperationException | InvocationTargetException unused) {
return null;
}
}
@CheckForNull
private static Method getJlaMethod(String str, Class<?>... clsArr) throws ThreadDeath {
try {
return Class.forName(JAVA_LANG_ACCESS_CLASSNAME, false, (ClassLoader) null).getMethod(str, clsArr);
} catch (ThreadDeath e) {
throw e;
} catch (Throwable unused) {
return null;
}
}
}
Download file