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/com/google/firebase/messaging/ByteStreams.java

@@ -0,0 +1,147 @@
+package com.google.firebase.messaging;
+
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Queue;
+import kotlin.jvm.internal.IntCompanionObject;
+
+/* loaded from: classes3.dex */
+final class ByteStreams {
+    private static final int BUFFER_SIZE = 8192;
+    private static final int MAX_ARRAY_LEN = 2147483639;
+    private static final int TO_BYTE_ARRAY_DEQUE_SIZE = 20;
+
+    private ByteStreams() {
+    }
+
+    private static byte[] combineBuffers(Queue<byte[]> queue, int i) {
+        if (queue.isEmpty()) {
+            return new byte[0];
+        }
+        byte[] remove = queue.remove();
+        if (remove.length == i) {
+            return remove;
+        }
+        int length = i - remove.length;
+        byte[] copyOf = Arrays.copyOf(remove, i);
+        while (length > 0) {
+            byte[] remove2 = queue.remove();
+            int min = Math.min(length, remove2.length);
+            System.arraycopy(remove2, 0, copyOf, i - length, min);
+            length -= min;
+        }
+        return copyOf;
+    }
+
+    public static byte[] createBuffer() {
+        return new byte[8192];
+    }
+
+    public static InputStream limit(InputStream inputStream, long j4) {
+        return new LimitedInputStream(inputStream, j4);
+    }
+
+    private static int saturatedCast(long j4) {
+        if (j4 > 2147483647L) {
+            return Integer.MAX_VALUE;
+        }
+        return j4 < -2147483648L ? IntCompanionObject.MIN_VALUE : (int) j4;
+    }
+
+    public static byte[] toByteArray(InputStream inputStream) throws IOException {
+        return toByteArrayInternal(inputStream, new ArrayDeque(20), 0);
+    }
+
+    private static byte[] toByteArrayInternal(InputStream inputStream, Queue<byte[]> queue, int i) throws IOException {
+        int min = Math.min(8192, Math.max(128, Integer.highestOneBit(i) * 2));
+        while (i < MAX_ARRAY_LEN) {
+            int min2 = Math.min(min, MAX_ARRAY_LEN - i);
+            byte[] bArr = new byte[min2];
+            queue.add(bArr);
+            int i4 = 0;
+            while (i4 < min2) {
+                int read = inputStream.read(bArr, i4, min2 - i4);
+                if (read == -1) {
+                    return combineBuffers(queue, i);
+                }
+                i4 += read;
+                i += read;
+            }
+            min = saturatedCast(min * (min < 4096 ? 4 : 2));
+        }
+        if (inputStream.read() == -1) {
+            return combineBuffers(queue, MAX_ARRAY_LEN);
+        }
+        throw new OutOfMemoryError("input is too large to fit in a byte array");
+    }
+
+    /* loaded from: classes3.dex */
+    public static final class LimitedInputStream extends FilterInputStream {
+        private long left;
+        private long mark;
+
+        public LimitedInputStream(InputStream inputStream, long j4) {
+            super(inputStream);
+            this.mark = -1L;
+            this.left = j4;
+        }
+
+        @Override // java.io.FilterInputStream, java.io.InputStream
+        public int available() throws IOException {
+            return (int) Math.min(((FilterInputStream) this).in.available(), this.left);
+        }
+
+        @Override // java.io.FilterInputStream, java.io.InputStream
+        public synchronized void mark(int i) {
+            ((FilterInputStream) this).in.mark(i);
+            this.mark = this.left;
+        }
+
+        @Override // java.io.FilterInputStream, java.io.InputStream
+        public int read() throws IOException {
+            if (this.left == 0) {
+                return -1;
+            }
+            int read = ((FilterInputStream) this).in.read();
+            if (read != -1) {
+                this.left--;
+            }
+            return read;
+        }
+
+        @Override // java.io.FilterInputStream, java.io.InputStream
+        public synchronized void reset() throws IOException {
+            if (!((FilterInputStream) this).in.markSupported()) {
+                throw new IOException("Mark not supported");
+            }
+            if (this.mark == -1) {
+                throw new IOException("Mark not set");
+            }
+            ((FilterInputStream) this).in.reset();
+            this.left = this.mark;
+        }
+
+        @Override // java.io.FilterInputStream, java.io.InputStream
+        public long skip(long j4) throws IOException {
+            long skip = ((FilterInputStream) this).in.skip(Math.min(j4, this.left));
+            this.left -= skip;
+            return skip;
+        }
+
+        @Override // java.io.FilterInputStream, java.io.InputStream
+        public int read(byte[] bArr, int i, int i4) throws IOException {
+            long j4 = this.left;
+            if (j4 == 0) {
+                return -1;
+            }
+            int read = ((FilterInputStream) this).in.read(bArr, i, (int) Math.min(i4, j4));
+            if (read != -1) {
+                this.left -= read;
+            }
+            return read;
+        }
+    }
+}