reverse-skills-max: initial public release (restored, redacted, hardened)

vendor-new/apk-reverse/tests/unit/test_blob_decode.py

@@ -0,0 +1,186 @@
+"""Unit tests for skills/apk-reverse/scripts/blob_decode.py.
+
+The encoded-blob search is the part worth pinning: the whole method exists
+because a single un-rotated inflate attempt fails and the failure looks like
+"this is encrypted". The tests build blobs with known parameters and require the
+search to recover them.
+"""
+from __future__ import annotations
+
+import gzip
+import json
+import zlib
+
+import pytest
+
+from conftest import load_script, run_script
+
+blob_decode = load_script("blob_decode.py")
+
+pytestmark = pytest.mark.unit
+
+PAYLOAD = json.dumps({
+    "flags": {"newCheckout": True, "minVersion": 4210},
+    "endpoints": ["https://api.example.invalid/v3/config"],
+    "notes": "synthetic payload for the rotation search regression" * 3,
+}).encode("utf-8")
+
+
+# --------------------------------------------------------------------------- #
+# outer encodings
+# --------------------------------------------------------------------------- #
+class TestOuterEncodings:
+    @pytest.mark.parametrize("which", ["base64", "base64url", "hex"])
+    def test_round_trip(self, which):
+        data = bytes(range(64))
+        encoded = blob_decode.outer_encode(data, which)
+        assert blob_decode.outer_decode(encoded, which) == data
+
+    def test_unknown_encoding_raises(self):
+        with pytest.raises(ValueError):
+            blob_decode.outer_encode(b"x", "rot13")
+
+    def test_undecodable_hex_returns_empty_not_an_exception(self):
+        """The search calls this on candidate encodings; a raise would abort it."""
+        assert blob_decode.outer_decode("zzzz", "hex") == b""
+
+    def test_whitespace_and_newlines_are_stripped_before_decoding(self):
+        encoded = blob_decode.outer_encode(b"hello world", "base64")
+        wrapped = "\n".join([encoded[:4], encoded[4:]])
+        assert blob_decode.outer_decode(wrapped, "base64") == b"hello world"
+
+    def test_sniff_offers_all_three_encodings(self):
+        guesses = blob_decode.sniff_outer("aGVsbG8gd29ybGQgdGhpcyBpcyBhIHRlc3Q=")
+        assert set(guesses) >= {"base64", "base64url", "hex"}
+
+    def test_sniff_puts_hex_first_for_hex_shaped_text(self):
+        assert blob_decode.sniff_outer("deadbeef" * 8)[0] == "hex"
+
+
+# --------------------------------------------------------------------------- #
+# inner transforms
+# --------------------------------------------------------------------------- #
+class TestInnerTransforms:
+    def test_inflate_raw_round_trips_through_raw_deflate(self):
+        body = blob_decode.inflate_raw(PAYLOAD)
+        assert zlib.decompress(body, -15) == PAYLOAD
+
+    def test_inflate_raw_output_has_no_zlib_header(self):
+        """A raw stream is what the rotation search needs: no header to mis-align."""
+        body = blob_decode.inflate_raw(b"x" * 200)
+        with pytest.raises(zlib.error):
+            zlib.decompress(body)   # default wbits expects a zlib header
+
+    @pytest.mark.parametrize("name,blob", [
+        ("raw", zlib.compressobj(9, zlib.DEFLATED, -15)),
+        ("zlib", zlib.compressobj(9, zlib.DEFLATED, 15)),
+        ("gzip", zlib.compressobj(9, zlib.DEFLATED, 31)),
+    ])
+    def test_try_inflate_names_each_inner_transform(self, name, blob):
+        body = blob.compress(PAYLOAD) + blob.flush()
+        got = blob_decode.try_inflate(body)
+        assert got is not None
+        assert got[0] == name
+        assert got[1] == PAYLOAD
+
+    def test_try_inflate_returns_none_for_noise(self):
+        assert blob_decode.try_inflate(bytes(range(256))) is None
+
+    def test_gzip_is_accepted_via_the_stdlib_helper(self):
+        got = blob_decode.try_inflate(gzip.compress(PAYLOAD))
+        assert got is not None and got[0] == "gzip" and got[1] == PAYLOAD
+
+
+# --------------------------------------------------------------------------- #
+# scoring
+# --------------------------------------------------------------------------- #
+class TestScoring:
+    def test_structured_text_scores_above_random_bytes(self):
+        structured = blob_decode.score(PAYLOAD)
+        noise = blob_decode.score(bytes(range(256)) * 4)
+        assert structured > noise
+
+    def test_a_json_header_is_rewarded(self):
+        assert blob_decode.score(b'{"a": 1}') > blob_decode.score(b"aaaaaaaa")
+
+    def test_empty_output_scores_negative(self):
+        assert blob_decode.score(b"") < 0
+
+
+# --------------------------------------------------------------------------- #
+# the rotation search
+# --------------------------------------------------------------------------- #
+def rotate(body, cut):
+    return body[-cut:] + body[:-cut] if cut else body
+
+
+class TestRotationSearch:
+    def _hits(self, blob, max_skip=0):
+        return blob_decode.search(blob, max_skip, lambda _msg: None)
+
+    def test_search_recovers_a_rotated_raw_stream(self):
+        body = blob_decode.inflate_raw(PAYLOAD)
+        cut = 7
+        hits = self._hits(rotate(body, cut))
+        matching = [h for h in hits if h["data"] == PAYLOAD]
+        assert matching, "the rotation with cut=%d was not recovered" % cut
+        assert matching[0]["cut"] == cut
+        assert matching[0]["inner"] == "raw"
+        assert matching[0]["size"] == len(PAYLOAD)
+
+    def test_search_recovers_a_prefixed_and_rotated_stream(self):
+        """The `skip` arm: a short header in front of the compressed stream."""
+        body = blob_decode.inflate_raw(PAYLOAD)
+        blob = b"\x01\x02" + rotate(body, 5)
+        hits = self._hits(blob, max_skip=4)
+        matching = [h for h in hits if h["data"] == PAYLOAD]
+        assert matching, "skip=2 + cut=5 was not recovered"
+        assert matching[0]["skip"] == 2
+
+    def test_search_on_noise_returns_no_hits(self):
+        assert self._hits(bytes(range(64))) == []
+
+    def test_scores_are_reported_rounded(self):
+        body = blob_decode.inflate_raw(PAYLOAD)
+        hits = self._hits(body)
+        assert hits
+        assert all(isinstance(h["score"], float) for h in hits)
+
+    def test_the_shortest_accepted_body_is_eight_bytes(self):
+        """Documented floor: `m < 8` breaks the loop, so tiny blobs yield nothing."""
+        assert self._hits(b"\x01\x02\x03") == []
+
+
+# --------------------------------------------------------------------------- #
+# the CLI-level write-back contract
+# --------------------------------------------------------------------------- #
+class TestEncodePath:
+    def test_encode_then_decode_recovers_the_payload(self, tmp_path):
+        """The write-back line the tool prints must actually round-trip."""
+        payload_file = tmp_path / "payload.bin"
+        payload_file.write_bytes(PAYLOAD)
+
+        encoded_file = tmp_path / "value.txt"
+        enc = run_script("blob_decode.py",
+                         ["--encode", "--file", str(payload_file), "--inner", "raw",
+                          "--outer", "base64", "--cut", "0", "--out", str(encoded_file)])
+        assert enc.returncode == 0, enc.output
+
+        back = run_script("blob_decode.py",
+                          ["--file", str(encoded_file), "--outer", "base64",
+                           "--min-size", "1", "--out", str(tmp_path / "back.bin")])
+        assert back.returncode == 0, back.output
+        assert (tmp_path / "back.bin").read_bytes() == PAYLOAD
+
+    def test_an_undecodable_blob_exits_one(self, tmp_path):
+        value = tmp_path / "value.txt"
+        value.write_text("not-a-blob-at-all-just-prose-text\n", encoding="utf-8")
+        result = run_script("blob_decode.py", ["--file", str(value), "--outer", "hex"])
+        assert result.returncode == 1, result.output
+        assert not result.has_traceback
+
+    def test_empty_stdin_is_reported_as_invalid_input(self):
+        """Exit code 2, not 1: an empty input is invalid, not a failed decode."""
+        result = run_script("blob_decode.py", [], stdin="   ")
+        assert result.returncode == 2, result.output
+        assert "empty input" in result.output