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/g0/C0373a.java

@@ -0,0 +1,60 @@
+package g0;
+
+import android.media.MediaDataSource;
+import java.io.IOException;
+
+/* renamed from: g0.a, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0373a extends MediaDataSource {
+
+    /* renamed from: a, reason: collision with root package name */
+    public long f6680a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ f f6681b;
+
+    public C0373a(f fVar) {
+        this.f6681b = fVar;
+    }
+
+    @Override // java.io.Closeable, java.lang.AutoCloseable
+    public final void close() {
+    }
+
+    @Override // android.media.MediaDataSource
+    public final long getSize() {
+        return -1L;
+    }
+
+    @Override // android.media.MediaDataSource
+    public final int readAt(long j4, byte[] bArr, int i, int i4) {
+        if (i4 == 0) {
+            return 0;
+        }
+        if (j4 < 0) {
+            return -1;
+        }
+        try {
+            long j5 = this.f6680a;
+            f fVar = this.f6681b;
+            if (j5 != j4) {
+                if (j5 >= 0 && j4 >= j5 + fVar.f6684a.available()) {
+                    return -1;
+                }
+                fVar.e(j4);
+                this.f6680a = j4;
+            }
+            if (i4 > fVar.f6684a.available()) {
+                i4 = fVar.f6684a.available();
+            }
+            int read = fVar.read(bArr, i, i4);
+            if (read >= 0) {
+                this.f6680a += read;
+                return read;
+            }
+        } catch (IOException unused) {
+        }
+        this.f6680a = -1L;
+        return -1;
+    }
+}

apk_decompiled/sources/g0/b.java

@@ -0,0 +1,268 @@
+package g0;
+
+import C.w;
+import android.util.Log;
+import java.io.DataInput;
+import java.io.DataInputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteOrder;
+
+/* loaded from: classes.dex */
+public class b extends InputStream implements DataInput {
+
+    /* renamed from: e, reason: collision with root package name */
+    public static final ByteOrder f6682e = ByteOrder.LITTLE_ENDIAN;
+
+    /* renamed from: f, reason: collision with root package name */
+    public static final ByteOrder f6683f = ByteOrder.BIG_ENDIAN;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final DataInputStream f6684a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public ByteOrder f6685b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public int f6686c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public byte[] f6687d;
+
+    /* JADX WARN: Illegal instructions before constructor call */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public b(byte[] r2) {
+        /*
+            r1 = this;
+            java.io.ByteArrayInputStream r0 = new java.io.ByteArrayInputStream
+            r0.<init>(r2)
+            java.nio.ByteOrder r2 = java.nio.ByteOrder.BIG_ENDIAN
+            r2 = 0
+            r1.<init>(r0, r2)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: g0.b.<init>(byte[]):void");
+    }
+
+    @Override // java.io.InputStream
+    public final int available() {
+        return this.f6684a.available();
+    }
+
+    public final void d(int i) {
+        int i4 = 0;
+        while (i4 < i) {
+            DataInputStream dataInputStream = this.f6684a;
+            int i5 = i - i4;
+            int skip = (int) dataInputStream.skip(i5);
+            if (skip <= 0) {
+                if (this.f6687d == null) {
+                    this.f6687d = new byte[8192];
+                }
+                skip = dataInputStream.read(this.f6687d, 0, Math.min(8192, i5));
+                if (skip == -1) {
+                    throw new EOFException(w.i(i, "Reached EOF while skipping ", " bytes."));
+                }
+            }
+            i4 += skip;
+        }
+        this.f6686c += i4;
+    }
+
+    @Override // java.io.InputStream
+    public final void mark(int i) {
+        throw new UnsupportedOperationException("Mark is currently unsupported");
+    }
+
+    @Override // java.io.InputStream
+    public final int read() {
+        this.f6686c++;
+        return this.f6684a.read();
+    }
+
+    @Override // java.io.DataInput
+    public final boolean readBoolean() {
+        this.f6686c++;
+        return this.f6684a.readBoolean();
+    }
+
+    @Override // java.io.DataInput
+    public final byte readByte() {
+        this.f6686c++;
+        int read = this.f6684a.read();
+        if (read >= 0) {
+            return (byte) read;
+        }
+        throw new EOFException();
+    }
+
+    @Override // java.io.DataInput
+    public final char readChar() {
+        this.f6686c += 2;
+        return this.f6684a.readChar();
+    }
+
+    @Override // java.io.DataInput
+    public final double readDouble() {
+        return Double.longBitsToDouble(readLong());
+    }
+
+    @Override // java.io.DataInput
+    public final float readFloat() {
+        return Float.intBitsToFloat(readInt());
+    }
+
+    @Override // java.io.DataInput
+    public final void readFully(byte[] bArr, int i, int i4) {
+        this.f6686c += i4;
+        this.f6684a.readFully(bArr, i, i4);
+    }
+
+    @Override // java.io.DataInput
+    public final int readInt() {
+        this.f6686c += 4;
+        DataInputStream dataInputStream = this.f6684a;
+        int read = dataInputStream.read();
+        int read2 = dataInputStream.read();
+        int read3 = dataInputStream.read();
+        int read4 = dataInputStream.read();
+        if ((read | read2 | read3 | read4) < 0) {
+            throw new EOFException();
+        }
+        ByteOrder byteOrder = this.f6685b;
+        if (byteOrder == f6682e) {
+            return (read4 << 24) + (read3 << 16) + (read2 << 8) + read;
+        }
+        if (byteOrder == f6683f) {
+            return (read << 24) + (read2 << 16) + (read3 << 8) + read4;
+        }
+        throw new IOException("Invalid byte order: " + this.f6685b);
+    }
+
+    @Override // java.io.DataInput
+    public final String readLine() {
+        Log.d("ExifInterface", "Currently unsupported");
+        return null;
+    }
+
+    @Override // java.io.DataInput
+    public final long readLong() {
+        this.f6686c += 8;
+        DataInputStream dataInputStream = this.f6684a;
+        int read = dataInputStream.read();
+        int read2 = dataInputStream.read();
+        int read3 = dataInputStream.read();
+        int read4 = dataInputStream.read();
+        int read5 = dataInputStream.read();
+        int read6 = dataInputStream.read();
+        int read7 = dataInputStream.read();
+        int read8 = dataInputStream.read();
+        if ((read | read2 | read3 | read4 | read5 | read6 | read7 | read8) < 0) {
+            throw new EOFException();
+        }
+        ByteOrder byteOrder = this.f6685b;
+        if (byteOrder == f6682e) {
+            return (read8 << 56) + (read7 << 48) + (read6 << 40) + (read5 << 32) + (read4 << 24) + (read3 << 16) + (read2 << 8) + read;
+        }
+        if (byteOrder == f6683f) {
+            return (read << 56) + (read2 << 48) + (read3 << 40) + (read4 << 32) + (read5 << 24) + (read6 << 16) + (read7 << 8) + read8;
+        }
+        throw new IOException("Invalid byte order: " + this.f6685b);
+    }
+
+    @Override // java.io.DataInput
+    public final short readShort() {
+        int i;
+        this.f6686c += 2;
+        DataInputStream dataInputStream = this.f6684a;
+        int read = dataInputStream.read();
+        int read2 = dataInputStream.read();
+        if ((read | read2) < 0) {
+            throw new EOFException();
+        }
+        ByteOrder byteOrder = this.f6685b;
+        if (byteOrder == f6682e) {
+            i = (read2 << 8) + read;
+        } else {
+            if (byteOrder != f6683f) {
+                throw new IOException("Invalid byte order: " + this.f6685b);
+            }
+            i = (read << 8) + read2;
+        }
+        return (short) i;
+    }
+
+    @Override // java.io.DataInput
+    public final String readUTF() {
+        this.f6686c += 2;
+        return this.f6684a.readUTF();
+    }
+
+    @Override // java.io.DataInput
+    public final int readUnsignedByte() {
+        this.f6686c++;
+        return this.f6684a.readUnsignedByte();
+    }
+
+    @Override // java.io.DataInput
+    public final int readUnsignedShort() {
+        this.f6686c += 2;
+        DataInputStream dataInputStream = this.f6684a;
+        int read = dataInputStream.read();
+        int read2 = dataInputStream.read();
+        if ((read | read2) < 0) {
+            throw new EOFException();
+        }
+        ByteOrder byteOrder = this.f6685b;
+        if (byteOrder == f6682e) {
+            return (read2 << 8) + read;
+        }
+        if (byteOrder == f6683f) {
+            return (read << 8) + read2;
+        }
+        throw new IOException("Invalid byte order: " + this.f6685b);
+    }
+
+    @Override // java.io.InputStream
+    public final void reset() {
+        throw new UnsupportedOperationException("Reset is currently unsupported");
+    }
+
+    @Override // java.io.DataInput
+    public final int skipBytes(int i) {
+        throw new UnsupportedOperationException("skipBytes is currently unsupported");
+    }
+
+    /* JADX WARN: 'this' call moved to the top of the method (can break code semantics) */
+    public b(InputStream inputStream) {
+        this(inputStream, 0);
+        ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
+    }
+
+    public b(InputStream inputStream, int i) {
+        ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
+        this.f6685b = byteOrder;
+        DataInputStream dataInputStream = new DataInputStream(inputStream);
+        this.f6684a = dataInputStream;
+        dataInputStream.mark(0);
+        this.f6686c = 0;
+        this.f6685b = byteOrder;
+    }
+
+    @Override // java.io.InputStream
+    public final int read(byte[] bArr, int i, int i4) {
+        int read = this.f6684a.read(bArr, i, i4);
+        this.f6686c += read;
+        return read;
+    }
+
+    @Override // java.io.DataInput
+    public final void readFully(byte[] bArr) {
+        this.f6686c += bArr.length;
+        this.f6684a.readFully(bArr);
+    }
+}

apk_decompiled/sources/g0/c.java

@@ -0,0 +1,206 @@
+package g0;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes.dex */
+public final class c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final int f6688a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final int f6689b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final long f6690c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final byte[] f6691d;
+
+    public c(int i, int i4, byte[] bArr) {
+        this(-1L, bArr, i, i4);
+    }
+
+    public static c a(long j4, ByteOrder byteOrder) {
+        long[] jArr = {j4};
+        ByteBuffer wrap = ByteBuffer.wrap(new byte[g.f6702E[4]]);
+        wrap.order(byteOrder);
+        wrap.putInt((int) jArr[0]);
+        return new c(4, 1, wrap.array());
+    }
+
+    public static c b(e eVar, ByteOrder byteOrder) {
+        ByteBuffer wrap = ByteBuffer.wrap(new byte[g.f6702E[5]]);
+        wrap.order(byteOrder);
+        e eVar2 = new e[]{eVar}[0];
+        wrap.putInt((int) eVar2.f6696a);
+        wrap.putInt((int) eVar2.f6697b);
+        return new c(5, 1, wrap.array());
+    }
+
+    public static c c(int i, ByteOrder byteOrder) {
+        ByteBuffer wrap = ByteBuffer.wrap(new byte[g.f6702E[3]]);
+        wrap.order(byteOrder);
+        wrap.putShort((short) new int[]{i}[0]);
+        return new c(3, 1, wrap.array());
+    }
+
+    public final double d(ByteOrder byteOrder) {
+        Object g4 = g(byteOrder);
+        if (g4 == null) {
+            throw new NumberFormatException("NULL can't be converted to a double value");
+        }
+        if (g4 instanceof String) {
+            return Double.parseDouble((String) g4);
+        }
+        if (g4 instanceof long[]) {
+            if (((long[]) g4).length == 1) {
+                return r3[0];
+            }
+            throw new NumberFormatException("There are more than one component");
+        }
+        if (g4 instanceof int[]) {
+            if (((int[]) g4).length == 1) {
+                return r3[0];
+            }
+            throw new NumberFormatException("There are more than one component");
+        }
+        if (g4 instanceof double[]) {
+            double[] dArr = (double[]) g4;
+            if (dArr.length == 1) {
+                return dArr[0];
+            }
+            throw new NumberFormatException("There are more than one component");
+        }
+        if (!(g4 instanceof e[])) {
+            throw new NumberFormatException("Couldn't find a double value");
+        }
+        e[] eVarArr = (e[]) g4;
+        if (eVarArr.length != 1) {
+            throw new NumberFormatException("There are more than one component");
+        }
+        e eVar = eVarArr[0];
+        return eVar.f6696a / eVar.f6697b;
+    }
+
+    public final int e(ByteOrder byteOrder) {
+        Object g4 = g(byteOrder);
+        if (g4 == null) {
+            throw new NumberFormatException("NULL can't be converted to a integer value");
+        }
+        if (g4 instanceof String) {
+            return Integer.parseInt((String) g4);
+        }
+        if (g4 instanceof long[]) {
+            long[] jArr = (long[]) g4;
+            if (jArr.length == 1) {
+                return (int) jArr[0];
+            }
+            throw new NumberFormatException("There are more than one component");
+        }
+        if (!(g4 instanceof int[])) {
+            throw new NumberFormatException("Couldn't find a integer value");
+        }
+        int[] iArr = (int[]) g4;
+        if (iArr.length == 1) {
+            return iArr[0];
+        }
+        throw new NumberFormatException("There are more than one component");
+    }
+
+    public final String f(ByteOrder byteOrder) {
+        Object g4 = g(byteOrder);
+        if (g4 == null) {
+            return null;
+        }
+        if (g4 instanceof String) {
+            return (String) g4;
+        }
+        StringBuilder sb = new StringBuilder();
+        int i = 0;
+        if (g4 instanceof long[]) {
+            long[] jArr = (long[]) g4;
+            while (i < jArr.length) {
+                sb.append(jArr[i]);
+                i++;
+                if (i != jArr.length) {
+                    sb.append(",");
+                }
+            }
+            return sb.toString();
+        }
+        if (g4 instanceof int[]) {
+            int[] iArr = (int[]) g4;
+            while (i < iArr.length) {
+                sb.append(iArr[i]);
+                i++;
+                if (i != iArr.length) {
+                    sb.append(",");
+                }
+            }
+            return sb.toString();
+        }
+        if (g4 instanceof double[]) {
+            double[] dArr = (double[]) g4;
+            while (i < dArr.length) {
+                sb.append(dArr[i]);
+                i++;
+                if (i != dArr.length) {
+                    sb.append(",");
+                }
+            }
+            return sb.toString();
+        }
+        if (!(g4 instanceof e[])) {
+            return null;
+        }
+        e[] eVarArr = (e[]) g4;
+        while (i < eVarArr.length) {
+            sb.append(eVarArr[i].f6696a);
+            sb.append('/');
+            sb.append(eVarArr[i].f6697b);
+            i++;
+            if (i != eVarArr.length) {
+                sb.append(",");
+            }
+        }
+        return sb.toString();
+    }
+
+    /* JADX WARN: Not initialized variable reg: 6, insn: 0x0033: MOVE (r5 I:??[OBJECT, ARRAY]) = (r6 I:??[OBJECT, ARRAY]), block:B:162:0x0033 */
+    /* JADX WARN: Removed duplicated region for block: B:165:0x016d A[EXC_TOP_SPLITTER, SYNTHETIC] */
+    /* JADX WARN: Type inference failed for: r14v14, types: [int[], java.io.Serializable] */
+    /* JADX WARN: Type inference failed for: r14v15, types: [long[], java.io.Serializable] */
+    /* JADX WARN: Type inference failed for: r14v16, types: [g0.e[], java.io.Serializable] */
+    /* JADX WARN: Type inference failed for: r14v17, types: [int[], java.io.Serializable] */
+    /* JADX WARN: Type inference failed for: r14v18, types: [int[], java.io.Serializable] */
+    /* JADX WARN: Type inference failed for: r14v19, types: [g0.e[], java.io.Serializable] */
+    /* JADX WARN: Type inference failed for: r14v20, types: [double[], java.io.Serializable] */
+    /* JADX WARN: Type inference failed for: r14v21, types: [double[], java.io.Serializable] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final java.io.Serializable g(java.nio.ByteOrder r14) {
+        /*
+            Method dump skipped, instructions count: 402
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: g0.c.g(java.nio.ByteOrder):java.io.Serializable");
+    }
+
+    public final String toString() {
+        StringBuilder sb = new StringBuilder("(");
+        sb.append(g.f6701D[this.f6688a]);
+        sb.append(", data length:");
+        return com.google.android.gms.measurement.internal.a.m(sb, this.f6691d.length, ")");
+    }
+
+    public c(long j4, byte[] bArr, int i, int i4) {
+        this.f6688a = i;
+        this.f6689b = i4;
+        this.f6690c = j4;
+        this.f6691d = bArr;
+    }
+}

apk_decompiled/sources/g0/d.java

@@ -0,0 +1,31 @@
+package g0;
+
+/* loaded from: classes.dex */
+public final class d {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final int f6692a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final String f6693b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final int f6694c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final int f6695d;
+
+    public d(String str, int i, int i4) {
+        this.f6693b = str;
+        this.f6692a = i;
+        this.f6694c = i4;
+        this.f6695d = -1;
+    }
+
+    public d(String str, int i, int i4, int i5) {
+        this.f6693b = str;
+        this.f6692a = i;
+        this.f6694c = i4;
+        this.f6695d = i5;
+    }
+}

apk_decompiled/sources/g0/e.java

@@ -0,0 +1,27 @@
+package g0;
+
+import com.google.firebase.sessions.settings.RemoteSettings;
+
+/* loaded from: classes.dex */
+public final class e {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final long f6696a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final long f6697b;
+
+    public e(long j4, long j5) {
+        if (j5 == 0) {
+            this.f6696a = 0L;
+            this.f6697b = 1L;
+        } else {
+            this.f6696a = j4;
+            this.f6697b = j5;
+        }
+    }
+
+    public final String toString() {
+        return this.f6696a + RemoteSettings.FORWARD_SLASH_STRING + this.f6697b;
+    }
+}

apk_decompiled/sources/g0/f.java

@@ -0,0 +1,31 @@
+package g0;
+
+import java.io.InputStream;
+
+/* loaded from: classes.dex */
+public final class f extends b {
+    public f(byte[] bArr) {
+        super(bArr);
+        this.f6684a.mark(Integer.MAX_VALUE);
+    }
+
+    public final void e(long j4) {
+        int i = this.f6686c;
+        if (i > j4) {
+            this.f6686c = 0;
+            this.f6684a.reset();
+        } else {
+            j4 -= i;
+        }
+        d((int) j4);
+    }
+
+    public f(InputStream inputStream) {
+        super(inputStream);
+        if (inputStream.markSupported()) {
+            this.f6684a.mark(Integer.MAX_VALUE);
+            return;
+        }
+        throw new IllegalArgumentException("Cannot create SeekableByteOrderedDataInputStream with stream that does not support mark/reset");
+    }
+}

apk_decompiled/sources/g0/h.java

@@ -0,0 +1,20 @@
+package g0;
+
+import android.system.ErrnoException;
+import android.system.Os;
+import java.io.FileDescriptor;
+
+/* loaded from: classes.dex */
+public abstract class h {
+    public static void a(FileDescriptor fileDescriptor) throws ErrnoException {
+        Os.close(fileDescriptor);
+    }
+
+    public static FileDescriptor b(FileDescriptor fileDescriptor) throws ErrnoException {
+        return Os.dup(fileDescriptor);
+    }
+
+    public static long c(FileDescriptor fileDescriptor, long j4, int i) throws ErrnoException {
+        return Os.lseek(fileDescriptor, j4, i);
+    }
+}

apk_decompiled/sources/g0/i.java

@@ -0,0 +1,11 @@
+package g0;
+
+import android.media.MediaDataSource;
+import android.media.MediaMetadataRetriever;
+
+/* loaded from: classes.dex */
+public abstract class i {
+    public static void a(MediaMetadataRetriever mediaMetadataRetriever, MediaDataSource mediaDataSource) {
+        mediaMetadataRetriever.setDataSource(mediaDataSource);
+    }
+}