ffproto 1.0.0__tar.gz

ffproto-1.0.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: ffproto
+Version: 1.0.0
+Summary: Encryption/decryption library for Free Fire HTTP protobuf payloads
+Home-page: https://github.com/yourusername/ffproto
+Author: RedZed / PARAHEX
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: pycryptodome>=3.9.0
+Requires-Dist: protobuf>=3.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="ffproto",
+    version="1.0.0",
+    author="Eren",
+    description="Encryption/decryption library for Free Fire HTTP protobuf payloads",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/ffproto",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+    install_requires=[
+        "pycryptodome>=3.9.0",
+        "protobuf>=3.0.0",
+    ],
+)

ffproto-1.0.0/README.md

@@ -0,0 +1,25 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="ffproto",
+    version="1.0.0",
+    author="Eren",
+    description="Encryption/decryption library for Free Fire HTTP protobuf payloads",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/ffproto",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+    install_requires=[
+        "pycryptodome>=3.9.0",
+        "protobuf>=3.0.0",
+    ],
+)

ffproto-1.0.0/ff_decoder/__init__.py

@@ -0,0 +1,22 @@
+"""
+ffproto – Free Fire protobuf encryption/decryption library.
+"""
+
+from .core import (
+    build_payload,
+    encrypt_payload,
+    decrypt_payload,
+    decode_protobuf,
+    encrypt_fields,
+    decrypt_hex,
+)
+
+__version__ = "1.0.0"
+__all__ = [
+    "build_payload",
+    "encrypt_payload",
+    "decrypt_payload",
+    "decode_protobuf",
+    "encrypt_fields",
+    "decrypt_hex",
+]

ffproto-1.0.0/ff_decoder/core.py

@@ -0,0 +1,54 @@
+"""
+High-level functions: build, encrypt, decrypt, and decode.
+"""
+
+from typing import Dict, Any, Union
+from .protobuf import build_payload, decode_protobuf, convert_keys_to_str
+from .crypto import encrypt_packet, decrypt_packet
+
+
+def encrypt_fields(fields: Dict[int, Any]) -> bytes:
+    """
+    Build protobuf from dict, encrypt it, and return ciphertext bytes.
+    """
+    plaintext = build_payload(fields)
+    return encrypt_packet(plaintext)
+
+
+def encrypt_fields_hex(fields: Dict[int, Any]) -> str:
+    """Same as encrypt_fields but returns hex string."""
+    return encrypt_fields(fields).hex()
+
+
+def decrypt_hex(hex_data: str) -> Dict[int, Any]:
+    """
+    Decrypt hex string, then decode protobuf, returning dict with int keys.
+    If decryption fails, tries to decode as plain protobuf.
+    """
+    try:
+        data = bytes.fromhex(hex_data)
+    except ValueError:
+        raise ValueError("Invalid hex string")
+
+    # Try decryption
+    try:
+        plaintext = decrypt_packet(data)
+    except Exception:
+        # Maybe it's already plaintext
+        plaintext = data
+
+    # Decode protobuf
+    try:
+        decoded = decode_protobuf(plaintext)
+    except Exception as e:
+        raise ValueError(f"Failed to decode protobuf: {e}")
+
+    return decoded
+
+
+def decrypt_hex_json(hex_data: str) -> str:
+    """
+    Decrypt and decode, then return JSON string with string keys.
+    """
+    decoded = decrypt_hex(hex_data)
+    return json.dumps(convert_keys_to_str(decoded), indent=2, ensure_ascii=False, default=str)

ffproto-1.0.0/ff_decoder/crypto.py

@@ -0,0 +1,43 @@
+"""
+AES‑CBC encryption/decryption with fixed key/IV.
+"""
+
+from Crypto.Cipher import AES
+
+# Fixed key and IV (taken from the original code)
+AES_KEY = bytes([89, 103, 38, 116, 99, 37, 68, 69, 117, 104, 54, 37, 90, 99, 94, 56])
+AES_IV = bytes([54, 111, 121, 90, 68, 114, 50, 50, 69, 51, 121, 99, 104, 106, 77, 37])
+
+
+def pkcs7_pad(data: bytes, block_size: int = 16) -> bytes:
+    """Apply PKCS#7 padding."""
+    pad_len = block_size - (len(data) % block_size)
+    return data + bytes([pad_len]) * pad_len
+
+
+def pkcs7_unpad(data: bytes) -> bytes:
+    """Remove PKCS#7 padding."""
+    pad = data[-1]
+    if pad < 1 or pad > 16:
+        raise ValueError("Invalid padding")
+    return data[:-pad]
+
+
+def encrypt_packet(plaintext: bytes) -> bytes:
+    """
+    Encrypt plaintext bytes with AES‑CBC (fixed key/IV).
+    Returns ciphertext.
+    """
+    cipher = AES.new(AES_KEY, AES.MODE_CBC, AES_IV)
+    padded = pkcs7_pad(plaintext)
+    return cipher.encrypt(padded)
+
+
+def decrypt_packet(ciphertext: bytes) -> bytes:
+    """
+    Decrypt ciphertext with AES‑CBC and remove padding.
+    Returns plaintext bytes.
+    """
+    cipher = AES.new(AES_KEY, AES.MODE_CBC, AES_IV)
+    padded = cipher.decrypt(ciphertext)
+    return pkcs7_unpad(padded)

ffproto-1.0.0/ff_decoder/protobuf.py

@@ -0,0 +1,173 @@
+"""
+Protobuf encoding/decoding (varint, length-delimited, nested messages).
+Mirrors the logic in xPARA.py and the original decoder.
+"""
+
+from typing import Dict, Any, Union, List
+from google.protobuf.internal.decoder import _DecodeVarint, _DecodeVarint32
+
+
+def encode_varint(value: int) -> bytes:
+    """Encode an integer as protobuf varint."""
+    out = []
+    while True:
+        b = value & 0x7F
+        value >>= 7
+        if value:
+            out.append(b | 0x80)
+        else:
+            out.append(b)
+            break
+    return bytes(out)
+
+
+def encode_packed_varints(field_num: int, values: List[int]) -> bytes:
+    """Encode a repeated int field as packed varints (wire type 2)."""
+    packed_data = b''.join(encode_varint(v) for v in values)
+    tag = (field_num << 3) | 2
+    return encode_varint(tag) + encode_varint(len(packed_data)) + packed_data
+
+
+def encode_field(field_num: int, value: Any) -> bytes:
+    """
+    Encode a single field (scalar, string, bytes, or nested message).
+    Raises TypeError for unsupported types.
+    """
+    if isinstance(value, int):
+        tag = (field_num << 3) | 0
+        return encode_varint(tag) + encode_varint(value)
+    elif isinstance(value, str):
+        data = value.encode('utf-8')
+        tag = (field_num << 3) | 2
+        return encode_varint(tag) + encode_varint(len(data)) + data
+    elif isinstance(value, bytes):
+        tag = (field_num << 3) | 2
+        return encode_varint(tag) + encode_varint(len(value)) + value
+    elif isinstance(value, dict):
+        sub_payload = build_payload(value)
+        tag = (field_num << 3) | 2
+        return encode_varint(tag) + encode_varint(len(sub_payload)) + sub_payload
+    else:
+        raise TypeError(f"Unsupported type for field {field_num}: {type(value)}")
+
+
+def build_payload(fields: Dict[int, Any]) -> bytes:
+    """
+    Build a protobuf payload from a dict.
+    Keys are field numbers (int), values are:
+      - int (varint)
+      - str (UTF-8 string)
+      - bytes (raw bytes)
+      - dict (nested message)
+      - list of ints (packed varints, all ints)
+      - list of other values (repeated fields)
+    """
+    payload = b''
+    for key, value in fields.items():
+        field_num = int(key)
+        if isinstance(value, list):
+            # If all ints, use packed encoding (wire type 2)
+            if value and all(isinstance(v, int) for v in value):
+                payload += encode_packed_varints(field_num, value)
+            else:
+                # Repeated non-int: encode each as separate field
+                for elem in value:
+                    payload += encode_field(field_num, elem)
+        else:
+            payload += encode_field(field_num, value)
+    return payload
+
+
+# ---------- Decoding ----------
+
+def try_decode_packed_varints(data: bytes) -> List[int]:
+    """Attempt to parse data as packed varints."""
+    pos = 0
+    values = []
+    while pos < len(data):
+        val, pos = _DecodeVarint(data, pos)
+        values.append(val)
+    if pos != len(data):
+        raise ValueError("Not all bytes consumed")
+    return values
+
+
+def smart_decode(raw: bytes) -> Any:
+    """
+    Try to decode raw bytes as protobuf, then as text, then as packed varints.
+    Fallback to raw bytes.
+    """
+    # Try nested protobuf
+    try:
+        return decode_protobuf(raw)
+    except Exception:
+        pass
+    # Try UTF-8 text (if mostly printable)
+    try:
+        text = raw.decode('utf-8')
+        if sum(c.isprintable() for c in text) / max(len(text), 1) > 0.8:
+            return text
+    except Exception:
+        pass
+    # Try packed varints
+    try:
+        return try_decode_packed_varints(raw)
+    except Exception:
+        pass
+    # Return raw bytes (hex representation in final output)
+    return raw
+
+
+def decode_protobuf(data: bytes) -> Dict[int, Any]:
+    """
+    Decode a protobuf message into a dict with int keys.
+    Supports varint, length-delimited, 32-bit, and 64-bit wire types.
+    """
+    pos = 0
+    length = len(data)
+    fields = {}
+    while pos < length:
+        key, pos = _DecodeVarint(data, pos)
+        field_num = key >> 3
+        wire_type = key & 7
+
+        if wire_type == 0:
+            value, pos = _DecodeVarint(data, pos)
+        elif wire_type == 2:
+            size, pos = _DecodeVarint32(data, pos)
+            if pos + size > length:
+                raise ValueError(f"Truncated field {field_num}")
+            raw = data[pos:pos + size]
+            pos += size
+            value = smart_decode(raw)
+        elif wire_type == 5:  # 32-bit fixed
+            if pos + 4 > length:
+                raise ValueError(f"Truncated 32-bit field {field_num}")
+            value = int.from_bytes(data[pos:pos + 4], "little")
+            pos += 4
+        elif wire_type == 1:  # 64-bit fixed
+            if pos + 8 > length:
+                raise ValueError(f"Truncated 64-bit field {field_num}")
+            value = int.from_bytes(data[pos:pos + 8], "little")
+            pos += 8
+        else:
+            raise ValueError(f"Unsupported wire type: {wire_type}")
+
+        # Handle repeated fields: collect into list
+        if field_num in fields:
+            if not isinstance(fields[field_num], list):
+                fields[field_num] = [fields[field_num]]
+            fields[field_num].append(value)
+        else:
+            fields[field_num] = value
+    return fields
+
+
+def convert_keys_to_str(obj: Any) -> Any:
+    """Recursively convert dict keys from int to str for JSON serialization."""
+    if isinstance(obj, dict):
+        return {str(k): convert_keys_to_str(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [convert_keys_to_str(item) for item in obj]
+    else:
+        return obj

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

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: ffproto
+Version: 1.0.0
+Summary: Encryption/decryption library for Free Fire HTTP protobuf payloads
+Home-page: https://github.com/yourusername/ffproto
+Author: RedZed / PARAHEX
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: pycryptodome>=3.9.0
+Requires-Dist: protobuf>=3.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="ffproto",
+    version="1.0.0",
+    author="Eren",
+    description="Encryption/decryption library for Free Fire HTTP protobuf payloads",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/ffproto",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+    install_requires=[
+        "pycryptodome>=3.9.0",
+        "protobuf>=3.0.0",
+    ],
+)

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

@@ -0,0 +1,11 @@
+README.md
+setup.py
+ff_decoder/__init__.py
+ff_decoder/core.py
+ff_decoder/crypto.py
+ff_decoder/protobuf.py
+ffproto.egg-info/PKG-INFO
+ffproto.egg-info/SOURCES.txt
+ffproto.egg-info/dependency_links.txt
+ffproto.egg-info/requires.txt
+ffproto.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+pycryptodome>=3.9.0
+protobuf>=3.0.0

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

@@ -0,0 +1 @@
+ff_decoder

ffproto-1.0.0/setup.cfg

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

ffproto-1.0.0/setup.py

@@ -0,0 +1,25 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="ffproto",
+    version="1.0.0",
+    author="RedZed / PARAHEX",
+    description="Encryption/decryption library for Free Fire HTTP protobuf payloads",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/ffproto",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+    install_requires=[
+        "pycryptodome>=3.9.0",
+        "protobuf>=3.0.0",
+    ],
+)