Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.
This commit is contained in:
467
apk_decompiled/sources/retrofit2/Utils.java
Normal file
467
apk_decompiled/sources/retrofit2/Utils.java
Normal file
@@ -0,0 +1,467 @@
|
||||
package retrofit2;
|
||||
|
||||
import C.w;
|
||||
import e3.T;
|
||||
import java.io.IOException;
|
||||
import java.lang.annotation.Annotation;
|
||||
import java.lang.reflect.Array;
|
||||
import java.lang.reflect.GenericArrayType;
|
||||
import java.lang.reflect.Method;
|
||||
import java.lang.reflect.ParameterizedType;
|
||||
import java.lang.reflect.Type;
|
||||
import java.lang.reflect.TypeVariable;
|
||||
import java.lang.reflect.WildcardType;
|
||||
import java.util.Arrays;
|
||||
import java.util.NoSuchElementException;
|
||||
import java.util.Objects;
|
||||
import r3.InterfaceC0578j;
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
final class Utils {
|
||||
static final Type[] EMPTY_TYPE_ARRAY = new Type[0];
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public static final class GenericArrayTypeImpl implements GenericArrayType {
|
||||
private final Type componentType;
|
||||
|
||||
public GenericArrayTypeImpl(Type type) {
|
||||
this.componentType = type;
|
||||
}
|
||||
|
||||
public boolean equals(Object obj) {
|
||||
return (obj instanceof GenericArrayType) && Utils.equals(this, (GenericArrayType) obj);
|
||||
}
|
||||
|
||||
@Override // java.lang.reflect.GenericArrayType
|
||||
public Type getGenericComponentType() {
|
||||
return this.componentType;
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
return this.componentType.hashCode();
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return w.r(new StringBuilder(), Utils.typeToString(this.componentType), "[]");
|
||||
}
|
||||
}
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public static final class ParameterizedTypeImpl implements ParameterizedType {
|
||||
private final Type ownerType;
|
||||
private final Type rawType;
|
||||
private final Type[] typeArguments;
|
||||
|
||||
public ParameterizedTypeImpl(Type type, Type type2, Type... typeArr) {
|
||||
if (type2 instanceof Class) {
|
||||
if ((type == null) != (((Class) type2).getEnclosingClass() == null)) {
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
}
|
||||
for (Type type3 : typeArr) {
|
||||
Objects.requireNonNull(type3, "typeArgument == null");
|
||||
Utils.checkNotPrimitive(type3);
|
||||
}
|
||||
this.ownerType = type;
|
||||
this.rawType = type2;
|
||||
this.typeArguments = (Type[]) typeArr.clone();
|
||||
}
|
||||
|
||||
public boolean equals(Object obj) {
|
||||
return (obj instanceof ParameterizedType) && Utils.equals(this, (ParameterizedType) obj);
|
||||
}
|
||||
|
||||
@Override // java.lang.reflect.ParameterizedType
|
||||
public Type[] getActualTypeArguments() {
|
||||
return (Type[]) this.typeArguments.clone();
|
||||
}
|
||||
|
||||
@Override // java.lang.reflect.ParameterizedType
|
||||
public Type getOwnerType() {
|
||||
return this.ownerType;
|
||||
}
|
||||
|
||||
@Override // java.lang.reflect.ParameterizedType
|
||||
public Type getRawType() {
|
||||
return this.rawType;
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
int hashCode = Arrays.hashCode(this.typeArguments) ^ this.rawType.hashCode();
|
||||
Type type = this.ownerType;
|
||||
return (type != null ? type.hashCode() : 0) ^ hashCode;
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
Type[] typeArr = this.typeArguments;
|
||||
if (typeArr.length == 0) {
|
||||
return Utils.typeToString(this.rawType);
|
||||
}
|
||||
StringBuilder sb = new StringBuilder((typeArr.length + 1) * 30);
|
||||
sb.append(Utils.typeToString(this.rawType));
|
||||
sb.append("<");
|
||||
sb.append(Utils.typeToString(this.typeArguments[0]));
|
||||
for (int i = 1; i < this.typeArguments.length; i++) {
|
||||
sb.append(", ");
|
||||
sb.append(Utils.typeToString(this.typeArguments[i]));
|
||||
}
|
||||
sb.append(">");
|
||||
return sb.toString();
|
||||
}
|
||||
}
|
||||
|
||||
/* loaded from: classes3.dex */
|
||||
public static final class WildcardTypeImpl implements WildcardType {
|
||||
private final Type lowerBound;
|
||||
private final Type upperBound;
|
||||
|
||||
public WildcardTypeImpl(Type[] typeArr, Type[] typeArr2) {
|
||||
if (typeArr2.length > 1) {
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
if (typeArr.length != 1) {
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
if (typeArr2.length != 1) {
|
||||
typeArr[0].getClass();
|
||||
Utils.checkNotPrimitive(typeArr[0]);
|
||||
this.lowerBound = null;
|
||||
this.upperBound = typeArr[0];
|
||||
return;
|
||||
}
|
||||
typeArr2[0].getClass();
|
||||
Utils.checkNotPrimitive(typeArr2[0]);
|
||||
if (typeArr[0] != Object.class) {
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
this.lowerBound = typeArr2[0];
|
||||
this.upperBound = Object.class;
|
||||
}
|
||||
|
||||
public boolean equals(Object obj) {
|
||||
return (obj instanceof WildcardType) && Utils.equals(this, (WildcardType) obj);
|
||||
}
|
||||
|
||||
@Override // java.lang.reflect.WildcardType
|
||||
public Type[] getLowerBounds() {
|
||||
Type type = this.lowerBound;
|
||||
return type != null ? new Type[]{type} : Utils.EMPTY_TYPE_ARRAY;
|
||||
}
|
||||
|
||||
@Override // java.lang.reflect.WildcardType
|
||||
public Type[] getUpperBounds() {
|
||||
return new Type[]{this.upperBound};
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
Type type = this.lowerBound;
|
||||
return (this.upperBound.hashCode() + 31) ^ (type != null ? type.hashCode() + 31 : 1);
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
if (this.lowerBound != null) {
|
||||
return "? super " + Utils.typeToString(this.lowerBound);
|
||||
}
|
||||
if (this.upperBound == Object.class) {
|
||||
return "?";
|
||||
}
|
||||
return "? extends " + Utils.typeToString(this.upperBound);
|
||||
}
|
||||
}
|
||||
|
||||
private Utils() {
|
||||
}
|
||||
|
||||
/* JADX WARN: Multi-variable type inference failed */
|
||||
/* JADX WARN: Type inference failed for: r0v0, types: [r3.i, r3.j, java.lang.Object] */
|
||||
public static T buffer(T t2) throws IOException {
|
||||
?? obj = new Object();
|
||||
t2.source().U(obj);
|
||||
return T.create(t2.contentType(), t2.contentLength(), (InterfaceC0578j) obj);
|
||||
}
|
||||
|
||||
public static void checkNotPrimitive(Type type) {
|
||||
if ((type instanceof Class) && ((Class) type).isPrimitive()) {
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
}
|
||||
|
||||
private static Class<?> declaringClassOf(TypeVariable<?> typeVariable) {
|
||||
Object genericDeclaration = typeVariable.getGenericDeclaration();
|
||||
if (genericDeclaration instanceof Class) {
|
||||
return (Class) genericDeclaration;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static boolean equals(Type type, Type type2) {
|
||||
if (type == type2) {
|
||||
return true;
|
||||
}
|
||||
if (type instanceof Class) {
|
||||
return type.equals(type2);
|
||||
}
|
||||
if (type instanceof ParameterizedType) {
|
||||
if (!(type2 instanceof ParameterizedType)) {
|
||||
return false;
|
||||
}
|
||||
ParameterizedType parameterizedType = (ParameterizedType) type;
|
||||
ParameterizedType parameterizedType2 = (ParameterizedType) type2;
|
||||
Type ownerType = parameterizedType.getOwnerType();
|
||||
Type ownerType2 = parameterizedType2.getOwnerType();
|
||||
return (ownerType == ownerType2 || (ownerType != null && ownerType.equals(ownerType2))) && parameterizedType.getRawType().equals(parameterizedType2.getRawType()) && Arrays.equals(parameterizedType.getActualTypeArguments(), parameterizedType2.getActualTypeArguments());
|
||||
}
|
||||
if (type instanceof GenericArrayType) {
|
||||
if (type2 instanceof GenericArrayType) {
|
||||
return equals(((GenericArrayType) type).getGenericComponentType(), ((GenericArrayType) type2).getGenericComponentType());
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (type instanceof WildcardType) {
|
||||
if (!(type2 instanceof WildcardType)) {
|
||||
return false;
|
||||
}
|
||||
WildcardType wildcardType = (WildcardType) type;
|
||||
WildcardType wildcardType2 = (WildcardType) type2;
|
||||
return Arrays.equals(wildcardType.getUpperBounds(), wildcardType2.getUpperBounds()) && Arrays.equals(wildcardType.getLowerBounds(), wildcardType2.getLowerBounds());
|
||||
}
|
||||
if (!(type instanceof TypeVariable) || !(type2 instanceof TypeVariable)) {
|
||||
return false;
|
||||
}
|
||||
TypeVariable typeVariable = (TypeVariable) type;
|
||||
TypeVariable typeVariable2 = (TypeVariable) type2;
|
||||
return typeVariable.getGenericDeclaration() == typeVariable2.getGenericDeclaration() && typeVariable.getName().equals(typeVariable2.getName());
|
||||
}
|
||||
|
||||
public static Type getGenericSupertype(Type type, Class<?> cls, Class<?> cls2) {
|
||||
if (cls2 == cls) {
|
||||
return type;
|
||||
}
|
||||
if (cls2.isInterface()) {
|
||||
Class<?>[] interfaces = cls.getInterfaces();
|
||||
int length = interfaces.length;
|
||||
for (int i = 0; i < length; i++) {
|
||||
Class<?> cls3 = interfaces[i];
|
||||
if (cls3 == cls2) {
|
||||
return cls.getGenericInterfaces()[i];
|
||||
}
|
||||
if (cls2.isAssignableFrom(cls3)) {
|
||||
return getGenericSupertype(cls.getGenericInterfaces()[i], interfaces[i], cls2);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!cls.isInterface()) {
|
||||
while (cls != Object.class) {
|
||||
Class<? super Object> superclass = cls.getSuperclass();
|
||||
if (superclass == cls2) {
|
||||
return cls.getGenericSuperclass();
|
||||
}
|
||||
if (cls2.isAssignableFrom(superclass)) {
|
||||
return getGenericSupertype(cls.getGenericSuperclass(), superclass, cls2);
|
||||
}
|
||||
cls = superclass;
|
||||
}
|
||||
}
|
||||
return cls2;
|
||||
}
|
||||
|
||||
public static Type getParameterLowerBound(int i, ParameterizedType parameterizedType) {
|
||||
Type type = parameterizedType.getActualTypeArguments()[i];
|
||||
return type instanceof WildcardType ? ((WildcardType) type).getLowerBounds()[0] : type;
|
||||
}
|
||||
|
||||
public static Type getParameterUpperBound(int i, ParameterizedType parameterizedType) {
|
||||
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
|
||||
if (i >= 0 && i < actualTypeArguments.length) {
|
||||
Type type = actualTypeArguments[i];
|
||||
return type instanceof WildcardType ? ((WildcardType) type).getUpperBounds()[0] : type;
|
||||
}
|
||||
StringBuilder t2 = w.t(i, "Index ", " not in range [0,");
|
||||
t2.append(actualTypeArguments.length);
|
||||
t2.append(") for ");
|
||||
t2.append(parameterizedType);
|
||||
throw new IllegalArgumentException(t2.toString());
|
||||
}
|
||||
|
||||
public static Class<?> getRawType(Type type) {
|
||||
Objects.requireNonNull(type, "type == null");
|
||||
if (type instanceof Class) {
|
||||
return (Class) type;
|
||||
}
|
||||
if (type instanceof ParameterizedType) {
|
||||
Type rawType = ((ParameterizedType) type).getRawType();
|
||||
if (rawType instanceof Class) {
|
||||
return (Class) rawType;
|
||||
}
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
if (type instanceof GenericArrayType) {
|
||||
return Array.newInstance(getRawType(((GenericArrayType) type).getGenericComponentType()), 0).getClass();
|
||||
}
|
||||
if (type instanceof TypeVariable) {
|
||||
return Object.class;
|
||||
}
|
||||
if (type instanceof WildcardType) {
|
||||
return getRawType(((WildcardType) type).getUpperBounds()[0]);
|
||||
}
|
||||
throw new IllegalArgumentException("Expected a Class, ParameterizedType, or GenericArrayType, but <" + type + "> is of type " + type.getClass().getName());
|
||||
}
|
||||
|
||||
public static Type getSupertype(Type type, Class<?> cls, Class<?> cls2) {
|
||||
if (cls2.isAssignableFrom(cls)) {
|
||||
return resolve(type, cls, getGenericSupertype(type, cls, cls2));
|
||||
}
|
||||
throw new IllegalArgumentException();
|
||||
}
|
||||
|
||||
public static boolean hasUnresolvableType(Type type) {
|
||||
if (type instanceof Class) {
|
||||
return false;
|
||||
}
|
||||
if (type instanceof ParameterizedType) {
|
||||
for (Type type2 : ((ParameterizedType) type).getActualTypeArguments()) {
|
||||
if (hasUnresolvableType(type2)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if (type instanceof GenericArrayType) {
|
||||
return hasUnresolvableType(((GenericArrayType) type).getGenericComponentType());
|
||||
}
|
||||
if ((type instanceof TypeVariable) || (type instanceof WildcardType)) {
|
||||
return true;
|
||||
}
|
||||
throw new IllegalArgumentException("Expected a Class, ParameterizedType, or GenericArrayType, but <" + type + "> is of type " + (type == null ? "null" : type.getClass().getName()));
|
||||
}
|
||||
|
||||
private static int indexOf(Object[] objArr, Object obj) {
|
||||
for (int i = 0; i < objArr.length; i++) {
|
||||
if (obj.equals(objArr[i])) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
throw new NoSuchElementException();
|
||||
}
|
||||
|
||||
public static boolean isAnnotationPresent(Annotation[] annotationArr, Class<? extends Annotation> cls) {
|
||||
for (Annotation annotation : annotationArr) {
|
||||
if (cls.isInstance(annotation)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public static RuntimeException methodError(Method method, String str, Object... objArr) {
|
||||
return methodError(method, null, str, objArr);
|
||||
}
|
||||
|
||||
public static RuntimeException parameterError(Method method, Throwable th, int i, String str, Object... objArr) {
|
||||
return methodError(method, th, str + " (parameter #" + (i + 1) + ")", objArr);
|
||||
}
|
||||
|
||||
public static Type resolve(Type type, Class<?> cls, Type type2) {
|
||||
Type type3 = type2;
|
||||
while (type3 instanceof TypeVariable) {
|
||||
TypeVariable typeVariable = (TypeVariable) type3;
|
||||
Type resolveTypeVariable = resolveTypeVariable(type, cls, typeVariable);
|
||||
if (resolveTypeVariable == typeVariable) {
|
||||
return resolveTypeVariable;
|
||||
}
|
||||
type3 = resolveTypeVariable;
|
||||
}
|
||||
if (type3 instanceof Class) {
|
||||
Class cls2 = (Class) type3;
|
||||
if (cls2.isArray()) {
|
||||
Class<?> componentType = cls2.getComponentType();
|
||||
Type resolve = resolve(type, cls, componentType);
|
||||
return componentType == resolve ? cls2 : new GenericArrayTypeImpl(resolve);
|
||||
}
|
||||
}
|
||||
if (type3 instanceof GenericArrayType) {
|
||||
GenericArrayType genericArrayType = (GenericArrayType) type3;
|
||||
Type genericComponentType = genericArrayType.getGenericComponentType();
|
||||
Type resolve2 = resolve(type, cls, genericComponentType);
|
||||
return genericComponentType == resolve2 ? genericArrayType : new GenericArrayTypeImpl(resolve2);
|
||||
}
|
||||
if (type3 instanceof ParameterizedType) {
|
||||
ParameterizedType parameterizedType = (ParameterizedType) type3;
|
||||
Type ownerType = parameterizedType.getOwnerType();
|
||||
Type resolve3 = resolve(type, cls, ownerType);
|
||||
boolean z3 = resolve3 != ownerType;
|
||||
Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
|
||||
int length = actualTypeArguments.length;
|
||||
for (int i = 0; i < length; i++) {
|
||||
Type resolve4 = resolve(type, cls, actualTypeArguments[i]);
|
||||
if (resolve4 != actualTypeArguments[i]) {
|
||||
if (!z3) {
|
||||
actualTypeArguments = (Type[]) actualTypeArguments.clone();
|
||||
z3 = true;
|
||||
}
|
||||
actualTypeArguments[i] = resolve4;
|
||||
}
|
||||
}
|
||||
return z3 ? new ParameterizedTypeImpl(resolve3, parameterizedType.getRawType(), actualTypeArguments) : parameterizedType;
|
||||
}
|
||||
boolean z4 = type3 instanceof WildcardType;
|
||||
Type type4 = type3;
|
||||
if (z4) {
|
||||
WildcardType wildcardType = (WildcardType) type3;
|
||||
Type[] lowerBounds = wildcardType.getLowerBounds();
|
||||
Type[] upperBounds = wildcardType.getUpperBounds();
|
||||
if (lowerBounds.length == 1) {
|
||||
Type resolve5 = resolve(type, cls, lowerBounds[0]);
|
||||
type4 = wildcardType;
|
||||
if (resolve5 != lowerBounds[0]) {
|
||||
return new WildcardTypeImpl(new Type[]{Object.class}, new Type[]{resolve5});
|
||||
}
|
||||
} else {
|
||||
type4 = wildcardType;
|
||||
if (upperBounds.length == 1) {
|
||||
Type resolve6 = resolve(type, cls, upperBounds[0]);
|
||||
type4 = wildcardType;
|
||||
if (resolve6 != upperBounds[0]) {
|
||||
return new WildcardTypeImpl(new Type[]{resolve6}, EMPTY_TYPE_ARRAY);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return type4;
|
||||
}
|
||||
|
||||
private static Type resolveTypeVariable(Type type, Class<?> cls, TypeVariable<?> typeVariable) {
|
||||
Class<?> declaringClassOf = declaringClassOf(typeVariable);
|
||||
if (declaringClassOf != null) {
|
||||
Type genericSupertype = getGenericSupertype(type, cls, declaringClassOf);
|
||||
if (genericSupertype instanceof ParameterizedType) {
|
||||
return ((ParameterizedType) genericSupertype).getActualTypeArguments()[indexOf(declaringClassOf.getTypeParameters(), typeVariable)];
|
||||
}
|
||||
}
|
||||
return typeVariable;
|
||||
}
|
||||
|
||||
public static void throwIfFatal(Throwable th) {
|
||||
if (th instanceof VirtualMachineError) {
|
||||
throw ((VirtualMachineError) th);
|
||||
}
|
||||
if (th instanceof ThreadDeath) {
|
||||
throw ((ThreadDeath) th);
|
||||
}
|
||||
if (th instanceof LinkageError) {
|
||||
throw ((LinkageError) th);
|
||||
}
|
||||
}
|
||||
|
||||
public static String typeToString(Type type) {
|
||||
return type instanceof Class ? ((Class) type).getName() : type.toString();
|
||||
}
|
||||
|
||||
public static RuntimeException methodError(Method method, Throwable th, String str, Object... objArr) {
|
||||
return new IllegalArgumentException(String.format(str, objArr) + "\n for method " + method.getDeclaringClass().getSimpleName() + "." + method.getName(), th);
|
||||
}
|
||||
|
||||
public static RuntimeException parameterError(Method method, int i, String str, Object... objArr) {
|
||||
return methodError(method, str + " (parameter #" + (i + 1) + ")", objArr);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user