crownx-decoder 1.0.0__tar.gz

crownx_decoder-1.0.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: crownx-decoder
+Version: 1.0.0
+Summary: Protobuf raw and AES decoder CLI tool
+Author: CrownX
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: pycryptodome
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Crownx Decoder
+
+Protobuf & AES Decoder CLI Tool.
+
+## Installation
+```bash
+pip install crownx-decoder

crownx_decoder-1.0.0/README.md

@@ -0,0 +1,7 @@
+# Crownx Decoder
+
+Protobuf & AES Decoder CLI Tool.
+
+## Installation
+```bash
+pip install crownx-decoder

crownx_decoder-1.0.0/crownx_decoder/decoder.py

@@ -0,0 +1,638 @@
+#!/usr/bin/env python3
+"""
+Protobuf Decoder - JSON Output Version
+Decodes a raw protobuf message given as hex or base64 text, and prints
+the result as beautifully formatted JSON. Nested messages are expanded automatically.
+"""
+
+import base64
+import struct
+import argparse
+import json
+import sys
+import re
+import os
+from datetime import datetime
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import unpad
+
+# ---------------------------------------------------------------------------
+# Wire types (same constants as protobufDecoder.js)
+# ---------------------------------------------------------------------------
+class TYPES:
+    MSG_LEN_DELIMITER = -1
+    VARINT = 0
+    FIXED64 = 1
+    LENDELIM = 2
+    FIXED32 = 5
+
+# ---------------------------------------------------------------------------
+# Input parsing (hexUtils.js)
+# ---------------------------------------------------------------------------
+def is_hex(s):
+    return bool(s) and all(c in "0123456789abcdef" for c in s) and len(s) % 2 == 0
+
+
+def parse_input(input_str, force_base64=False):
+    normalized = re.sub(r"\s", "", input_str)
+    normalized_hex = re.sub(r"0x", "", normalized, flags=re.IGNORECASE).lower()
+    if not force_base64 and is_hex(normalized_hex):
+        return bytes.fromhex(normalized_hex)
+    else:
+        # pad base64 if needed
+        padded = normalized + "=" * (-len(normalized) % 4)
+        return base64.b64decode(padded)
+
+
+def buffer_to_pretty_hex(b):
+    return " ".join(f"{c:02x}" for c in b)
+
+
+def buffer_le_to_be_hex(b):
+    output = ""
+    for v in b:
+        h = f"{v:x}"
+        if len(h) == 1:
+            h = "0" + h
+        output = h + output
+    return output
+
+# ---------------------------------------------------------------------------
+# Varint decoding (varintUtils.js)
+# ---------------------------------------------------------------------------
+def decode_varint(buffer, offset):
+    result = 0
+    shift = 0
+    byte = 0
+    start = offset
+    while True:
+        if offset >= len(buffer):
+            raise IndexError("Index out of bound decoding varint")
+        byte = buffer[offset]
+        offset += 1
+        result += (byte & 0x7F) << shift
+        shift += 7
+        if byte < 0x80:
+            break
+    return {"value": result, "length": offset - start}
+
+# ---------------------------------------------------------------------------
+# Signed/twos-complement helpers (intUtils.js)
+# ---------------------------------------------------------------------------
+def interpret_as_signed_type(n):
+    """ZigZag decode (protobuf sint semantics)."""
+    if n % 2 == 0:
+        return n // 2
+    else:
+        return -((n + 1) // 2)
+
+def interpret_as_twos_complement(n, bits):
+    """If the top bit within `bits` is set, interpret as a negative
+    two's-complement number of that bit width."""
+    sign_bit = (n >> (bits - 1)) & 1
+    if sign_bit == 1:
+        return n - (1 << bits)
+    return n
+
+# ---------------------------------------------------------------------------
+# BufferReader (protobufDecoder.js)
+# ---------------------------------------------------------------------------
+class BufferReader:
+    def __init__(self, buffer):
+        self.buffer = buffer
+        self.offset = 0
+        self.saved_offset = 0
+
+    def read_varint(self):
+        result = decode_varint(self.buffer, self.offset)
+        self.offset += result["length"]
+        return result["value"]
+
+    def read_buffer(self, length):
+        self.check_bytes(length)
+        result = self.buffer[self.offset:self.offset + length]
+        self.offset += length
+        return result
+
+    def try_skip_grpc_header(self):
+        backup_offset = self.offset
+        if self.left_bytes() >= 5 and self.buffer[self.offset] == 0:
+            self.offset += 1
+            length = struct.unpack_from(">I", self.buffer, self.offset)[0]
+            self.offset += 4
+            if length > self.left_bytes():
+                self.offset = backup_offset
+
+    def left_bytes(self):
+        return len(self.buffer) - self.offset
+
+    def check_bytes(self, length):
+        available = self.left_bytes()
+        if length > available:
+            raise ValueError(
+                f"Not enough bytes left. Requested: {length} left: {available}"
+            )
+
+    def checkpoint(self):
+        self.saved_offset = self.offset
+
+    def reset_to_checkpoint(self):
+        self.offset = self.saved_offset
+
+# ---------------------------------------------------------------------------
+# Core decode (decodeProto in protobufDecoder.js)
+# ---------------------------------------------------------------------------
+def decode_proto(buffer, parse_delimited=False, skip_grpc_header=False, scan_embedded=True):
+    reader = BufferReader(buffer)
+    parts = []
+
+    if skip_grpc_header:
+        reader.try_skip_grpc_header()
+
+    proto_buf_msg_length = 0
+    proto_buf_msg_end = 0
+
+    # ---------------------------------------------------------------
+    # Normal protobuf parser
+    # ---------------------------------------------------------------
+    while reader.left_bytes() > 0:
+        reader.checkpoint()
+        field_start = reader.offset
+
+        try:
+            if parse_delimited and proto_buf_msg_end == reader.offset:
+                proto_buf_msg_length = reader.read_varint()
+                proto_buf_msg_end = reader.offset + proto_buf_msg_length
+
+                parts.append({
+                    "index": -1,
+                    "type": TYPES.MSG_LEN_DELIMITER,
+                    "value": proto_buf_msg_length,
+                })
+
+            index_type = reader.read_varint()
+
+            type_ = index_type & 0b111
+            index = index_type >> 3
+
+            # -------------------------------------------------------
+            # Invalid protobuf field number
+            # -------------------------------------------------------
+            if index <= 0:
+                raise ValueError("Invalid protobuf field number")
+
+            # -------------------------------------------------------
+            # VARINT
+            # -------------------------------------------------------
+            if type_ == TYPES.VARINT:
+                value = reader.read_varint()
+
+            # -------------------------------------------------------
+            # FIXED64
+            # -------------------------------------------------------
+            elif type_ == TYPES.FIXED64:
+                value = reader.read_buffer(8)
+
+            # -------------------------------------------------------
+            # LENGTH DELIMITED
+            # -------------------------------------------------------
+            elif type_ == TYPES.LENDELIM:
+                length = reader.read_varint()
+
+                if length < 0 or length > reader.left_bytes():
+                    raise ValueError(
+                        f"Invalid length-delimited size: {length}"
+                    )
+
+                value = reader.read_buffer(length)
+
+            # -------------------------------------------------------
+            # START GROUP
+            # -------------------------------------------------------
+            elif type_ == 3:
+                group_start = reader.offset
+                depth = 1
+
+                while reader.left_bytes() > 0 and depth > 0:
+                    tag = reader.read_varint()
+                    wire = tag & 0x07
+
+                    if wire == 3:
+                        depth += 1
+
+                    elif wire == 4:
+                        depth -= 1
+
+                        if depth == 0:
+                            break
+
+                    elif wire == 0:
+                        reader.read_varint()
+
+                    elif wire == 1:
+                        reader.read_buffer(8)
+
+                    elif wire == 2:
+                        length = reader.read_varint()
+
+                        if length < 0 or length > reader.left_bytes():
+                            raise ValueError(
+                                "Invalid length inside group"
+                            )
+
+                        reader.read_buffer(length)
+
+                    elif wire == 5:
+                        reader.read_buffer(4)
+
+                    else:
+                        raise ValueError(
+                            f"Invalid wire type inside group: {wire}"
+                        )
+
+                if depth != 0:
+                    raise ValueError("Unterminated protobuf group")
+
+                group_end = reader.offset
+                value = buffer[group_start:group_end]
+
+            # -------------------------------------------------------
+            # END GROUP
+            # -------------------------------------------------------
+            elif type_ == 4:
+                raise ValueError("Unexpected END_GROUP")
+
+            # -------------------------------------------------------
+            # FIXED32
+            # -------------------------------------------------------
+            elif type_ == TYPES.FIXED32:
+                value = reader.read_buffer(4)
+
+            else:
+                raise ValueError(f"Unknown wire type: {type_}")
+
+            parts.append({
+                "index": index,
+                "type": type_,
+                "value": value,
+            })
+
+        except (ValueError, IndexError, struct.error):
+            reader.offset = field_start
+            break
+
+    leftover = reader.read_buffer(reader.left_bytes())
+
+    result = {
+        "parts": parts,
+        "leftOver": leftover,
+    }
+
+    # ---------------------------------------------------------------
+    # Embedded protobuf scan
+    # ---------------------------------------------------------------
+    parsed_bytes = len(buffer) - len(leftover)
+
+    has_bad_wire = any(
+        p.get("type") in (3, 4)
+        for p in parts
+    )
+
+    poor_parse = (
+        not parts
+        or has_bad_wire
+        or parsed_bytes < max(16, len(buffer) // 2)
+        or len(leftover) > max(16, len(buffer) // 2)
+    )
+
+    if scan_embedded and poor_parse and len(buffer) > 1:
+
+        best = None
+
+        # -----------------------------------------------------------
+        # Search every byte offset for a coherent protobuf message
+        # -----------------------------------------------------------
+        for start in range(1, len(buffer)):
+
+            try:
+                tag_info = decode_varint(buffer, start)
+
+                first_tag = tag_info["value"]
+                first_wire = first_tag & 0x07
+                first_field = first_tag >> 3
+
+                if first_field <= 0:
+                    continue
+
+                # Avoid false START_GROUP / END_GROUP candidates
+                if first_wire in (3, 4):
+                    continue
+
+            except (ValueError, IndexError, struct.error):
+                continue
+
+            # -------------------------------------------------------
+            # Parse candidate
+            # -------------------------------------------------------
+            candidate = decode_proto(
+                buffer[start:],
+                parse_delimited=False,
+                skip_grpc_header=False,
+                scan_embedded=False,
+            )
+
+            candidate_parts = candidate.get("parts", [])
+            candidate_left = candidate.get("leftOver", b"")
+
+            if not candidate_parts:
+                continue
+
+            # Reject candidates containing group wire types
+            if any(
+                p.get("type") in (3, 4)
+                for p in candidate_parts
+            ):
+                continue
+
+            candidate_buffer_length = len(buffer) - start
+
+            consumed = (
+                candidate_buffer_length
+                - len(candidate_left)
+            )
+
+            if consumed <= 0:
+                continue
+
+            # Require a meaningful protobuf sequence
+            if consumed < 32:
+                continue
+
+            if len(candidate_parts) < 3:
+                continue
+
+            # -------------------------------------------------------
+            # Candidate score
+            #
+            # Priority:
+            # 1. No leftover
+            # 2. Most consumed bytes
+            # 3. Most fields
+            # 4. Earliest offset
+            # -------------------------------------------------------
+            no_leftover = len(candidate_left) == 0
+
+            score = (
+                1 if no_leftover else 0,
+                consumed,
+                len(candidate_parts),
+                -start,
+            )
+
+            if best is None or score > best["score"]:
+                best = {
+                    "score": score,
+                    "offset": start,
+                    "decoded": candidate,
+                }
+
+        # -----------------------------------------------------------
+        # Use best embedded protobuf candidate
+        # -----------------------------------------------------------
+        if best is not None:
+            result = best["decoded"]
+
+            result["embeddedOffset"] = best["offset"]
+
+    return result
+
+# ---------------------------------------------------------------------------
+# Part decoders (protobufPartDecoder.jsx)
+# ---------------------------------------------------------------------------
+def decode_fixed32(value):
+    int_value = struct.unpack_from("<i", value)[0]
+    uint_value = struct.unpack_from("<I", value)[0]
+    float_value = struct.unpack_from("<f", value)[0]
+
+    result = [{"type": "int", "value": int_value}]
+    if int_value != uint_value:
+        result.append({"type": "uint", "value": uint_value})
+    result.append({"type": "float", "value": float_value})
+    return result
+
+
+def decode_fixed64(value):
+    double_value = struct.unpack_from("<d", value)[0]
+    uint_value = int(buffer_le_to_be_hex(value), 16)
+    int_value = interpret_as_twos_complement(uint_value, 64)
+
+    result = [{"type": "int", "value": str(int_value)}]
+    if int_value != uint_value:
+        result.append({"type": "uint", "value": str(uint_value)})
+    result.append({"type": "double", "value": double_value})
+    return result
+
+
+def decode_varint_parts(value):
+    result = []
+    uint_val = int(value)
+    result.append({"type": "uint", "value": str(uint_val)})
+
+    for bits in (8, 16, 32, 64):
+        int_val = interpret_as_twos_complement(uint_val, bits)
+        if int_val != uint_val:
+            result.append({"type": f"int{bits}", "value": str(int_val)})
+
+    signed_int_val = interpret_as_signed_type(uint_val)
+    if signed_int_val != uint_val:
+        result.append({"type": "sint", "value": str(signed_int_val)})
+
+    return result
+
+
+def decode_string_or_bytes(value):
+    if not len(value):
+        return {"type": "string|bytes", "value": ""}
+    try:
+        decoded_str = value.decode("utf-8")
+        
+        # 1. Agar string me valid JSON formatted text hai, toh use JSON object me parse karein
+        trimmed = decoded_str.strip()
+        if (trimmed.startswith("{") and trimmed.endswith("}")) or (trimmed.startswith("[") and trimmed.endswith("]")):
+            try:
+                parsed_json = json.loads(trimmed)
+                return {"type": "json", "value": parsed_json}
+            except json.JSONDecodeError:
+                pass
+
+        # 2. Check karein ki string me sirf printable characters hain ya garbage control characters bhi hain
+        is_printable = True
+        for char in decoded_str:
+            o = ord(char)
+            # Control characters (ASCII < 32) ko exclude karein (except tab, newline, carriage return)
+            if o < 32 and o not in (9, 10, 13):
+                is_printable = False
+                break
+                
+        if is_printable:
+            return {"type": "string", "value": decoded_str}
+        else:
+            # Agar control characters hain toh garbage string ke bajay binary hex return karein
+            return {"type": "bytes", "value": buffer_to_pretty_hex(value)}
+            
+    except UnicodeDecodeError:
+        return {"type": "bytes", "value": buffer_to_pretty_hex(value)}
+
+# ---------------------------------------------------------------------------
+# JSON Formatting Transformer
+# ---------------------------------------------------------------------------
+def process_decoded_to_dict(decoded):
+    """Recursively converts the raw parsed decoded dict into a clean JSON-serializable dictionary."""
+    out_parts = []
+    
+    for part in decoded["parts"]:
+        t = part["type"]
+        out_part = {
+            "field": part["index"] if part["index"] != -1 else None
+        }
+        
+        # Remove field key if it is None (e.g., MSG_LEN_DELIMITER)
+        if out_part["field"] is None:
+            del out_part["field"]
+        
+        if t == TYPES.VARINT:
+            out_part["type"] = "varint"
+            out_part["content"] = {d["type"]: d["value"] for d in decode_varint_parts(part["value"])}
+            
+        elif t == TYPES.FIXED64:
+            out_part["type"] = "fixed64"
+            out_part["content"] = {d["type"]: d["value"] for d in decode_fixed64(part["value"])}
+            
+        elif t == TYPES.FIXED32:
+            out_part["type"] = "fixed32"
+            out_part["content"] = {d["type"]: d["value"] for d in decode_fixed32(part["value"])}
+            
+        elif t == TYPES.LENDELIM:
+            raw = part["value"]
+            nested = decode_proto(raw)
+            # Exactly same nested check condition
+            if len(raw) > 0 and len(nested["leftOver"]) == 0 and len(nested["parts"]) > 0:
+                out_part["type"] = "protobuf"
+                out_part["content"] = process_decoded_to_dict(nested)
+            else:
+                dec_str = decode_string_or_bytes(raw)
+                out_part["type"] = dec_str["type"]
+                out_part["content"] = dec_str["value"]
+                
+        elif t == TYPES.MSG_LEN_DELIMITER:
+            out_part["type"] = "message_delimiter"
+            out_part["content"] = {"length": part["value"]}
+            
+        else:
+            out_part["type"] = "unknown"
+            out_part["content"] = buffer_to_pretty_hex(part.get("value", b""))
+            
+        out_parts.append(out_part)
+        
+    result = {"parts": out_parts}
+    
+    if len(decoded["leftOver"]) > 0:
+        result["leftOver"] = buffer_to_pretty_hex(decoded["leftOver"])
+        
+    return result
+
+# ---------------------------------------------------------------------------
+# AES Decryption Helper
+# ---------------------------------------------------------------------------
+def try_aes_decrypt(ciphertext):
+    key = b'Yg&tc%DEuh6%Zc^8'
+    iv = b'6oyZDr22E3ychjM%'
+    try:
+        cipher = AES.new(key, AES.MODE_CBC, iv)
+        # Decrypt karega aur PKCS7 padding remove karega
+        decrypted = unpad(cipher.decrypt(ciphertext), AES.block_size)
+        return decrypted
+    except Exception:
+        # Agar decrypt/unpad fail ho jaye to None return karega
+        return None
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+def main():
+    parser = argparse.ArgumentParser(
+        description="Decode a raw protobuf message (hex or base64) and print it as JSON."
+    )
+    parser.add_argument(
+        "data", nargs="?", help="Hex or base64 encoded protobuf bytes. Reads stdin if omitted."
+    )
+    parser.add_argument(
+        "--base64", action="store_true", help="Force interpreting input as base64."
+    )
+    parser.add_argument(
+        "--delimited", action="store_true",
+        help="Parse input as a stream of length-delimited messages (e.g. gRPC streaming)."
+    )
+    parser.add_argument(
+        "--grpc", action="store_true",
+        help="Try to skip a leading gRPC framing header (1 flag byte + 4 byte length)."
+    )
+    args = parser.parse_args()
+
+    raw_input = args.data if args.data is not None else sys.stdin.read()
+    if raw_input is None or raw_input.strip() == "":
+        print(json.dumps({"error": "No input provided."}, indent=2))
+        sys.exit(1)
+
+    try:
+        buffer = parse_input(raw_input, force_base64=args.base64)
+    except Exception as e:
+        print(json.dumps({"error": f"Failed to parse input as hex or base64: {e}"}, indent=2))
+        sys.exit(1)
+
+    # Pehle normal try karega
+    decoded = decode_proto(buffer, parse_delimited=args.delimited, skip_grpc_header=args.grpc)
+    
+    # Firr KEY (AES) se try karega
+    decrypted_buffer = try_aes_decrypt(buffer)
+    if decrypted_buffer is not None:
+        decoded_aes = decode_proto(decrypted_buffer, parse_delimited=args.delimited, skip_grpc_header=args.grpc)
+        # Agar AES wali decoding zyada valid lagti hai (leftOver kam hai ya normal parts zero the)
+        if len(decoded_aes["leftOver"]) <= len(decoded["leftOver"]) or not decoded["parts"]:
+            decoded = decoded_aes
+            decoded["is_aes_decrypted"] = True
+    
+    # Convert exactly parsed logic into a neat JSON dict and print it
+    json_data = process_decoded_to_dict(decoded)
+    
+    # Agar AES se decode hua hai toh JSON me indicator add kar dega
+    if decoded.get("is_aes_decrypted"):
+        json_data["is_aes_decrypted"] = True
+        
+    print(json.dumps(json_data, indent=2, ensure_ascii=False))
+
+    # Auto-save decoded JSON sequentially to /sdcard/#DECODED/
+    try:
+        dir_path = "/sdcard/#DECODED"
+        os.makedirs(dir_path, exist_ok=True)
+        date_str = datetime.now().strftime("%d-%m-%Y")
+        
+        index = 1
+        while True:
+            file_name = f"decoded{index}_{date_str}.json"
+            full_path = os.path.join(dir_path, file_name)
+            if not os.path.exists(full_path):
+                break
+            index += 1
+            
+        with open(full_path, "w", encoding="utf-8") as f:
+            json.dump(json_data, f, indent=2, ensure_ascii=False)
+            f.write(f"\n\ninput = {raw_input.strip()}\n")
+        print(f"\n[+] Saved to: {full_path}")
+    except Exception as e:
+        print(f"\n[-] Failed to auto-save file to /sdcard: {e}")
+
+
+if __name__ == "__main__":
+    main()
+    

crownx_decoder-1.0.0/crownx_decoder.egg-info/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: crownx-decoder
+Version: 1.0.0
+Summary: Protobuf raw and AES decoder CLI tool
+Author: CrownX
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: pycryptodome
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Crownx Decoder
+
+Protobuf & AES Decoder CLI Tool.
+
+## Installation
+```bash
+pip install crownx-decoder

crownx_decoder-1.0.0/crownx_decoder.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+setup.py
+crownx_decoder/__init__.py
+crownx_decoder/decoder.py
+crownx_decoder.egg-info/PKG-INFO
+crownx_decoder.egg-info/SOURCES.txt
+crownx_decoder.egg-info/dependency_links.txt
+crownx_decoder.egg-info/entry_points.txt
+crownx_decoder.egg-info/requires.txt
+crownx_decoder.egg-info/top_level.txt

crownx_decoder-1.0.0/crownx_decoder.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

crownx_decoder-1.0.0/crownx_decoder.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dec = crownx_decoder.decoder:main

crownx_decoder-1.0.0/crownx_decoder.egg-info/requires.txt

@@ -0,0 +1 @@
+pycryptodome

crownx_decoder-1.0.0/crownx_decoder.egg-info/top_level.txt

@@ -0,0 +1 @@
+crownx_decoder

crownx_decoder-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

crownx_decoder-1.0.0/setup.py

@@ -0,0 +1,20 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="crownx-decoder",
+    version="1.0.0",
+    author="CrownX",
+    description="Protobuf raw and AES decoder CLI tool",
+    long_description=open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    packages=find_packages(),
+    install_requires=[
+        "pycryptodome",
+    ],
+    entry_points={
+        "console_scripts": [
+            "dec = crownx_decoder.decoder:main",  # Isse terminal me 'dec' command register hoga
+        ],
+    },
+    python_requires=">=3.7",
+)