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.

apk_decompiled/sources/n3/a.java

@@ -0,0 +1,49 @@
+package n3;
+
+import android.net.ssl.SSLSockets;
+import f0.C0338b;
+import java.io.IOException;
+import java.util.List;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class a implements m {
+    @Override // n3.m
+    public final boolean a(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return SSLSockets.isSupportedSocket(sslSocket);
+    }
+
+    @Override // n3.m
+    public final String b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        String applicationProtocol = sslSocket.getApplicationProtocol();
+        if (applicationProtocol == null ? true : Intrinsics.areEqual(applicationProtocol, "")) {
+            return null;
+        }
+        return applicationProtocol;
+    }
+
+    @Override // n3.m
+    public final boolean c() {
+        m3.n nVar = m3.n.f7829a;
+        return C0338b.s();
+    }
+
+    @Override // n3.m
+    public final void d(SSLSocket sslSocket, String str, List protocols) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        Intrinsics.checkNotNullParameter(protocols, "protocols");
+        try {
+            SSLSockets.setUseSessionTickets(sslSocket, true);
+            SSLParameters sSLParameters = sslSocket.getSSLParameters();
+            m3.n nVar = m3.n.f7829a;
+            sSLParameters.setApplicationProtocols((String[]) C0338b.g(protocols).toArray(new String[0]));
+            sslSocket.setSSLParameters(sSLParameters);
+        } catch (IllegalArgumentException e4) {
+            throw new IOException("Android internal error", e4);
+        }
+    }
+}

apk_decompiled/sources/n3/b.java

@@ -0,0 +1,50 @@
+package n3;
+
+import a.AbstractC0105a;
+import android.net.http.X509TrustManagerExtensions;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.List;
+import javax.net.ssl.SSLPeerUnverifiedException;
+import javax.net.ssl.X509TrustManager;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class b extends AbstractC0105a {
+
+    /* renamed from: c, reason: collision with root package name */
+    public final X509TrustManager f7867c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final X509TrustManagerExtensions f7868d;
+
+    public b(X509TrustManager trustManager, X509TrustManagerExtensions x509TrustManagerExtensions) {
+        Intrinsics.checkNotNullParameter(trustManager, "trustManager");
+        Intrinsics.checkNotNullParameter(x509TrustManagerExtensions, "x509TrustManagerExtensions");
+        this.f7867c = trustManager;
+        this.f7868d = x509TrustManagerExtensions;
+    }
+
+    public final boolean equals(Object obj) {
+        return (obj instanceof b) && ((b) obj).f7867c == this.f7867c;
+    }
+
+    public final int hashCode() {
+        return System.identityHashCode(this.f7867c);
+    }
+
+    @Override // a.AbstractC0105a
+    public final List i(String hostname, List chain) {
+        Intrinsics.checkNotNullParameter(chain, "chain");
+        Intrinsics.checkNotNullParameter(hostname, "hostname");
+        try {
+            List<X509Certificate> checkServerTrusted = this.f7868d.checkServerTrusted((X509Certificate[]) chain.toArray(new X509Certificate[0]), "RSA", hostname);
+            Intrinsics.checkNotNullExpressionValue(checkServerTrusted, "x509TrustManagerExtensio…ficates, \"RSA\", hostname)");
+            return checkServerTrusted;
+        } catch (CertificateException e4) {
+            SSLPeerUnverifiedException sSLPeerUnverifiedException = new SSLPeerUnverifiedException(e4.getMessage());
+            sSLPeerUnverifiedException.initCause(e4);
+            throw sSLPeerUnverifiedException;
+        }
+    }
+}

apk_decompiled/sources/n3/c.java

@@ -0,0 +1,38 @@
+package n3;
+
+import e3.F;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.CopyOnWriteArraySet;
+import kotlin.collections.MapsKt;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public abstract class c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final CopyOnWriteArraySet f7869a = new CopyOnWriteArraySet();
+
+    /* renamed from: b, reason: collision with root package name */
+    public static final Map f7870b;
+
+    static {
+        LinkedHashMap linkedHashMap = new LinkedHashMap();
+        Package r22 = F.class.getPackage();
+        String name = r22 != null ? r22.getName() : null;
+        if (name != null) {
+            linkedHashMap.put(name, "OkHttp");
+        }
+        String name2 = F.class.getName();
+        Intrinsics.checkNotNullExpressionValue(name2, "OkHttpClient::class.java.name");
+        linkedHashMap.put(name2, "okhttp.OkHttpClient");
+        String name3 = l3.g.class.getName();
+        Intrinsics.checkNotNullExpressionValue(name3, "Http2::class.java.name");
+        linkedHashMap.put(name3, "okhttp.Http2");
+        String name4 = h3.e.class.getName();
+        Intrinsics.checkNotNullExpressionValue(name4, "TaskRunner::class.java.name");
+        linkedHashMap.put(name4, "okhttp.TaskRunner");
+        linkedHashMap.put("okhttp3.mockwebserver.MockWebServer", "okhttp.MockWebServer");
+        f7870b = MapsKt.toMap(linkedHashMap);
+    }
+}

apk_decompiled/sources/n3/d.java

@@ -0,0 +1,72 @@
+package n3;
+
+import android.util.Log;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt;
+import kotlin.text.StringsKt__StringsKt;
+
+/* loaded from: classes3.dex */
+public final class d extends Handler {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final d f7871a = new Handler();
+
+    @Override // java.util.logging.Handler
+    public final void close() {
+    }
+
+    @Override // java.util.logging.Handler
+    public final void flush() {
+    }
+
+    @Override // java.util.logging.Handler
+    public final void publish(LogRecord record) {
+        int indexOf$default;
+        int min;
+        Intrinsics.checkNotNullParameter(record, "record");
+        CopyOnWriteArraySet copyOnWriteArraySet = c.f7869a;
+        String loggerName = record.getLoggerName();
+        Intrinsics.checkNotNullExpressionValue(loggerName, "record.loggerName");
+        int intValue = record.getLevel().intValue();
+        Level level = Level.INFO;
+        int i = intValue > level.intValue() ? 5 : record.getLevel().intValue() == level.intValue() ? 4 : 3;
+        String message = record.getMessage();
+        Intrinsics.checkNotNullExpressionValue(message, "record.message");
+        Throwable thrown = record.getThrown();
+        Intrinsics.checkNotNullParameter(loggerName, "loggerName");
+        Intrinsics.checkNotNullParameter(message, "message");
+        String str = (String) c.f7870b.get(loggerName);
+        if (str == null) {
+            str = StringsKt.take(loggerName, 23);
+        }
+        if (Log.isLoggable(str, i)) {
+            if (thrown != null) {
+                message = message + '\n' + Log.getStackTraceString(thrown);
+            }
+            int length = message.length();
+            int i4 = 0;
+            while (i4 < length) {
+                indexOf$default = StringsKt__StringsKt.indexOf$default((CharSequence) message, '\n', i4, false, 4, (Object) null);
+                if (indexOf$default == -1) {
+                    indexOf$default = length;
+                }
+                while (true) {
+                    min = Math.min(indexOf$default, i4 + 4000);
+                    String substring = message.substring(i4, min);
+                    Intrinsics.checkNotNullExpressionValue(substring, "this as java.lang.String…ing(startIndex, endIndex)");
+                    Log.println(i, str, substring);
+                    if (min >= indexOf$default) {
+                        break;
+                    } else {
+                        i4 = min;
+                    }
+                }
+                i4 = min + 1;
+            }
+        }
+    }
+}

apk_decompiled/sources/n3/e.java

@@ -0,0 +1,34 @@
+package n3;
+
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.StringsKt__StringsJVMKt;
+
+/* loaded from: classes3.dex */
+public final class e implements k {
+    @Override // n3.k
+    public final boolean a(SSLSocket sslSocket) {
+        boolean startsWith$default;
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        String name = sslSocket.getClass().getName();
+        Intrinsics.checkNotNullExpressionValue(name, "sslSocket.javaClass.name");
+        startsWith$default = StringsKt__StringsJVMKt.startsWith$default(name, "com.google.android.gms.org.conscrypt.", false, 2, null);
+        return startsWith$default;
+    }
+
+    @Override // n3.k
+    public final m b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        e eVar = f.f7872f;
+        Class<?> cls = sslSocket.getClass();
+        Class<?> cls2 = cls;
+        while (!Intrinsics.areEqual(cls2.getSimpleName(), "OpenSSLSocketImpl")) {
+            cls2 = cls2.getSuperclass();
+            if (cls2 == null) {
+                throw new AssertionError("No OpenSSLSocketImpl superclass of socket of type " + cls);
+            }
+        }
+        Intrinsics.checkNotNull(cls2);
+        return new f(cls2);
+    }
+}

apk_decompiled/sources/n3/f.java

@@ -0,0 +1,105 @@
+package n3;
+
+import com.google.firebase.remoteconfig.RemoteConfigConstants;
+import f0.C0338b;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.List;
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.text.Charsets;
+
+/* loaded from: classes3.dex */
+public class f implements m {
+
+    /* renamed from: f, reason: collision with root package name */
+    public static final e f7872f;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Class f7873a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final Method f7874b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final Method f7875c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final Method f7876d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final Method f7877e;
+
+    /* JADX WARN: Type inference failed for: r0v1, types: [java.lang.Object, n3.e] */
+    static {
+        Intrinsics.checkNotNullParameter("com.google.android.gms.org.conscrypt", RemoteConfigConstants.RequestFieldKey.PACKAGE_NAME);
+        f7872f = new Object();
+    }
+
+    public f(Class sslSocketClass) {
+        Intrinsics.checkNotNullParameter(sslSocketClass, "sslSocketClass");
+        this.f7873a = sslSocketClass;
+        Method declaredMethod = sslSocketClass.getDeclaredMethod("setUseSessionTickets", Boolean.TYPE);
+        Intrinsics.checkNotNullExpressionValue(declaredMethod, "sslSocketClass.getDeclar…:class.javaPrimitiveType)");
+        this.f7874b = declaredMethod;
+        this.f7875c = sslSocketClass.getMethod("setHostname", String.class);
+        this.f7876d = sslSocketClass.getMethod("getAlpnSelectedProtocol", new Class[0]);
+        this.f7877e = sslSocketClass.getMethod("setAlpnProtocols", byte[].class);
+    }
+
+    @Override // n3.m
+    public final boolean a(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return this.f7873a.isInstance(sslSocket);
+    }
+
+    @Override // n3.m
+    public final String b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        if (!a(sslSocket)) {
+            return null;
+        }
+        try {
+            byte[] bArr = (byte[]) this.f7876d.invoke(sslSocket, new Object[0]);
+            if (bArr != null) {
+                return new String(bArr, Charsets.UTF_8);
+            }
+            return null;
+        } catch (IllegalAccessException e4) {
+            throw new AssertionError(e4);
+        } catch (InvocationTargetException e5) {
+            Throwable cause = e5.getCause();
+            if ((cause instanceof NullPointerException) && Intrinsics.areEqual(((NullPointerException) cause).getMessage(), "ssl == null")) {
+                return null;
+            }
+            throw new AssertionError(e5);
+        }
+    }
+
+    @Override // n3.m
+    public final boolean c() {
+        boolean z3 = m3.c.f7810e;
+        return m3.c.f7810e;
+    }
+
+    @Override // n3.m
+    public final void d(SSLSocket sslSocket, String str, List protocols) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        Intrinsics.checkNotNullParameter(protocols, "protocols");
+        if (a(sslSocket)) {
+            try {
+                this.f7874b.invoke(sslSocket, Boolean.TRUE);
+                if (str != null) {
+                    this.f7875c.invoke(sslSocket, str);
+                }
+                Method method = this.f7877e;
+                m3.n nVar = m3.n.f7829a;
+                method.invoke(sslSocket, C0338b.j(protocols));
+            } catch (IllegalAccessException e4) {
+                throw new AssertionError(e4);
+            } catch (InvocationTargetException e5) {
+                throw new AssertionError(e5);
+            }
+        }
+    }
+}

apk_decompiled/sources/n3/g.java

@@ -0,0 +1,21 @@
+package n3;
+
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class g implements k {
+    @Override // n3.k
+    public final boolean a(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        boolean z3 = m3.e.f7813d;
+        return false;
+    }
+
+    /* JADX WARN: Type inference failed for: r0v2, types: [n3.m, java.lang.Object] */
+    @Override // n3.k
+    public final m b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return new Object();
+    }
+}

apk_decompiled/sources/n3/h.java

@@ -0,0 +1,50 @@
+package n3;
+
+import f0.C0338b;
+import java.util.List;
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+import org.bouncycastle.jsse.BCSSLParameters;
+import org.bouncycastle.jsse.BCSSLSocket;
+
+/* loaded from: classes3.dex */
+public final class h implements m {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final g f7878a = new Object();
+
+    @Override // n3.m
+    public final boolean a(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return false;
+    }
+
+    @Override // n3.m
+    public final String b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        String applicationProtocol = ((BCSSLSocket) sslSocket).getApplicationProtocol();
+        if (applicationProtocol == null ? true : Intrinsics.areEqual(applicationProtocol, "")) {
+            return null;
+        }
+        return applicationProtocol;
+    }
+
+    @Override // n3.m
+    public final boolean c() {
+        boolean z3 = m3.e.f7813d;
+        return m3.e.f7813d;
+    }
+
+    @Override // n3.m
+    public final void d(SSLSocket sslSocket, String str, List protocols) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        Intrinsics.checkNotNullParameter(protocols, "protocols");
+        if (a(sslSocket)) {
+            BCSSLSocket bCSSLSocket = (BCSSLSocket) sslSocket;
+            BCSSLParameters parameters = bCSSLSocket.getParameters();
+            m3.n nVar = m3.n.f7829a;
+            parameters.setApplicationProtocols((String[]) C0338b.g(protocols).toArray(new String[0]));
+            bCSSLSocket.setParameters(parameters);
+        }
+    }
+}

apk_decompiled/sources/n3/i.java

@@ -0,0 +1,21 @@
+package n3;
+
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+import org.conscrypt.Conscrypt;
+
+/* loaded from: classes3.dex */
+public final class i implements k {
+    @Override // n3.k
+    public final boolean a(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return m3.h.f7816d && Conscrypt.isConscrypt(sslSocket);
+    }
+
+    /* JADX WARN: Type inference failed for: r0v2, types: [n3.m, java.lang.Object] */
+    @Override // n3.k
+    public final m b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return new Object();
+    }
+}

apk_decompiled/sources/n3/j.java

@@ -0,0 +1,46 @@
+package n3;
+
+import f0.C0338b;
+import java.util.List;
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+import org.conscrypt.Conscrypt;
+
+/* loaded from: classes3.dex */
+public final class j implements m {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final i f7879a = new Object();
+
+    @Override // n3.m
+    public final boolean a(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return Conscrypt.isConscrypt(sslSocket);
+    }
+
+    @Override // n3.m
+    public final String b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        if (a(sslSocket)) {
+            return Conscrypt.getApplicationProtocol(sslSocket);
+        }
+        return null;
+    }
+
+    @Override // n3.m
+    public final boolean c() {
+        boolean z3 = m3.h.f7816d;
+        return m3.h.f7816d;
+    }
+
+    @Override // n3.m
+    public final void d(SSLSocket sslSocket, String str, List protocols) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        Intrinsics.checkNotNullParameter(protocols, "protocols");
+        if (a(sslSocket)) {
+            Conscrypt.setUseSessionTickets(sslSocket, true);
+            m3.n nVar = m3.n.f7829a;
+            Conscrypt.setApplicationProtocols(sslSocket, (String[]) C0338b.g(protocols).toArray(new String[0]));
+        }
+    }
+}

apk_decompiled/sources/n3/k.java

@@ -0,0 +1,10 @@
+package n3;
+
+import javax.net.ssl.SSLSocket;
+
+/* loaded from: classes3.dex */
+public interface k {
+    boolean a(SSLSocket sSLSocket);
+
+    m b(SSLSocket sSLSocket);
+}

apk_decompiled/sources/n3/l.java

@@ -0,0 +1,62 @@
+package n3;
+
+import java.util.List;
+import javax.net.ssl.SSLSocket;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class l implements m {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final k f7880a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public m f7881b;
+
+    public l(k socketAdapterFactory) {
+        Intrinsics.checkNotNullParameter(socketAdapterFactory, "socketAdapterFactory");
+        this.f7880a = socketAdapterFactory;
+    }
+
+    @Override // n3.m
+    public final boolean a(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        return this.f7880a.a(sslSocket);
+    }
+
+    @Override // n3.m
+    public final String b(SSLSocket sslSocket) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        m e4 = e(sslSocket);
+        if (e4 != null) {
+            return e4.b(sslSocket);
+        }
+        return null;
+    }
+
+    @Override // n3.m
+    public final boolean c() {
+        return true;
+    }
+
+    @Override // n3.m
+    public final void d(SSLSocket sslSocket, String str, List protocols) {
+        Intrinsics.checkNotNullParameter(sslSocket, "sslSocket");
+        Intrinsics.checkNotNullParameter(protocols, "protocols");
+        m e4 = e(sslSocket);
+        if (e4 != null) {
+            e4.d(sslSocket, str, protocols);
+        }
+    }
+
+    public final synchronized m e(SSLSocket sSLSocket) {
+        try {
+            if (this.f7881b == null && this.f7880a.a(sSLSocket)) {
+                this.f7881b = this.f7880a.b(sSLSocket);
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return this.f7881b;
+    }
+}

apk_decompiled/sources/n3/m.java

@@ -0,0 +1,15 @@
+package n3;
+
+import java.util.List;
+import javax.net.ssl.SSLSocket;
+
+/* loaded from: classes3.dex */
+public interface m {
+    boolean a(SSLSocket sSLSocket);
+
+    String b(SSLSocket sSLSocket);
+
+    boolean c();
+
+    void d(SSLSocket sSLSocket, String str, List list);
+}

apk_decompiled/sources/n3/n.java

@@ -0,0 +1,8 @@
+package n3;
+
+/* loaded from: classes3.dex */
+public final class n extends f {
+
+    /* renamed from: g, reason: collision with root package name */
+    public static final /* synthetic */ int f7882g = 0;
+}