tiksignV1 0.1.0__tar.gz

tiksignv1-0.1.0/Argus.py

@@ -0,0 +1,30 @@
+import base64, hashlib
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from . import SM3, Simon
+from .CryptoHelpers import *
+from .UrlEncode import parseQueryParams
+from .ProtoBuf import Field, serialize
+SIGN_KEY=bytes.fromhex('ac1adaae95a7af94a5114ab3b3a97dd80050aa0a39314c40528caec95256c28c')
+SM3_OUTPUT=bytes.fromhex('fc78e0a9657a0c748ce51559903ccf03510e51d3cff232d71343e88a321c5304')
+MASK=0xffffffffffffffff
+def bodyHash(stub):
+    b=bytes(16) if not stub else hexDecodeString(stub); return SM3.hash(b)[:6]
+def queryHash(query): return SM3.hash(query if query else bytes(16))[:6]
+def _pad(b): n=16-len(b)%16; return b+bytes([n])*n
+def _enc_pb(data):
+    pb=_pad(data); keys=[le64(SM3_OUTPUT,i*8) for i in range(4)]; enc=bytearray()
+    for i in range(0,len(pb),16):
+        a,b=Simon.encrypt((le64(pb,i),le64(pb,i+8)),keys); out=bytearray(16); writeUint64LE(out,0,a); writeUint64LE(out,1,b); enc+=out
+    buf=bytearray(bytes.fromhex('f2f7fcfff2f7fcff')+enc); x=bytes(buf); xor=x[:8]; x=bytearray(x)
+    for i in range(8,len(x)): x[i]^=xor[i%8]
+    x.reverse(); payload=bytes.fromhex('a66ead9f7701d00c18')+bytes(x)+b'ao'
+    key=hashlib.md5(SIGN_KEY[:16]).digest(); iv=hashlib.md5(SIGN_KEY[16:]).digest()
+    ct=Cipher(algorithms.AES(key),modes.CBC(iv)).encryptor().update(_pad(payload))
+    return base64.b64encode(b'\xf2\x81'+ct).decode()
+def getSign(queryhash,stub,timestamp,aid,licenseID,platform,secDeviceID,sdkVersion,sdkVersionInt,randVal=None):
+    q=parseQueryParams(queryhash); deviceID=q.get('device_id',''); versionName=q.get('version_name',''); randInt=cryptoRandUint31() if randVal is None else randVal
+    b=[Field.varint_field(1,0x20200929<<1),Field.varint_field(2,2),Field.varint_field(3,randInt&0x7fffffff),Field.string(4,str(aid).encode()),Field.string(5,deviceID.encode()),Field.string(6,str(licenseID).encode()),Field.string(7,versionName.encode()),Field.string(8,sdkVersion.encode()),Field.varint_field(9,sdkVersionInt),Field.string(10,bytes(8)),Field.varint_field(11,platform),Field.varint_field(12,timestamp<<1),Field.string(13,bodyHash(stub)),Field.string(14,queryHash(queryhash))]
+    b.append(Field.string(15,serialize([Field.varint_field(1,1),Field.varint_field(2,1),Field.varint_field(3,1),Field.varint_field(7,3348294860)])))
+    b += [Field.string(16,secDeviceID.encode()),Field.string(20,b'none'),Field.varint_field(21,738)]
+    b.append(Field.string(23,serialize([Field.string(1,b'NX551J'),Field.varint_field(2,8196),Field.varint_field(4,2162219008)])))
+    b.append(Field.varint_field(25,2)); return _enc_pb(serialize(b))

tiksignv1-0.1.0/CryptoHelpers.py

@@ -0,0 +1,14 @@
+import hashlib, secrets, struct
+
+def md5hex(value):
+    return hashlib.md5(value.encode() if isinstance(value, str) else value).hexdigest()
+def md5hexFromBytes(value): return hashlib.md5(value).hexdigest()
+def md5Digest(value): return hashlib.md5(value.encode() if isinstance(value, str) else value).digest()
+def bytesToHex(value): return bytes(value).hex()
+def hexByte(value): return f'{value & 255:02x}'
+def firstDigestBytes(digest, n): return bytes.fromhex(digest[:2*n])
+def hexDecodeString(value): return bytes.fromhex(value)
+def cryptoRandByte(): return secrets.randbelow(256)
+def cryptoRandUint31(): return secrets.randbits(31)
+def le64(b, off=0): return struct.unpack_from('<Q', b, off)[0]
+def writeUint64LE(dst, index, value): struct.pack_into('<Q', dst, index*8, value & 0xffffffffffffffff)

tiksignv1-0.1.0/Gorgon.py

@@ -0,0 +1,22 @@
+from .CryptoHelpers import md5hex, firstDigestBytes, hexByte
+def _nibble_swap(b): return ((b>>4)&15)|((b&15)<<4)
+def _bit_reverse(b):
+    b=((b&0xf0)>>4)|((b&0x0f)<<4); b=((b&0xcc)>>2)|((b&0x33)<<2); return ((b&0xaa)>>1)|((b&0x55)<<1)
+def _hex_unix(v): return f'{v & 0xffffffff:08x}'
+def v1(params,payload,cookie,unix,b3,b7):
+    g=bytearray();
+    for s in (params,payload,cookie): g += firstDigestBytes(md5hex(s),4) if s else b'\0'*4
+    g += bytes((1,1,2,4)); g += firstDigestBytes(_hex_unix(unix),4)
+    val='8404'+hexByte(b7&0xf0)+hexByte(b3)+ '0000'+''.join(hexByte(x) for x in g)
+    return str(unix*1000),str(unix),val
+def v2(params,data,cookies,unix):
+    p=bytearray()
+    for s in (params,data,cookies): p += firstDigestBytes(md5hex(s),4) if s else b'\0'*4
+    p += bytes((0,6,11,28)) + int(unix&0xffffffff).to_bytes(4,'big')
+    key=bytes.fromhex('df77b940b99b8483d1b9cbd1f7c2b985c3d0fbc3')
+    e=bytearray(a^b for a,b in zip(p,key))
+    for i in range(20):
+        f=_bit_reverse(_nibble_swap(e[i])^e[(i+1)%20]); e[i]=(f^0xff^20)&255
+    return str(unix*1000),str(unix),'840280416000'+e.hex()
+def v3(params,data,cookies,unix):
+    a,b,c=v2(params,data,cookies,unix); return a,b,'0404b0d30000'+c[len('840280416000'):]

tiksignv1-0.1.0/Ladon.py

@@ -0,0 +1,22 @@
+import base64
+from .CryptoHelpers import *
+MASK=0xffffffffffffffff
+def ror64(v,n): return ((v>>n)|(v<<(64-n)))&MASK
+def paddingSize(size): return size if size%16==0 else size+(16-size%16)
+def _pad(data,size):
+    n=16-size%16; return data[:size]+bytes([n])*n
+def _encrypt_input(table,block):
+    d0,d1=le64(block),le64(block,8)
+    for i in range(0x22):
+        h=le64(table,i*8); d1=(h^(d0+ror64(d1,8)))&MASK; d0=(d1^ror64(d0,0x3d))&MASK
+    out=bytearray(16); writeUint64LE(out,0,d0); writeUint64LE(out,1,d1); return bytes(out)
+def encryptLadon(md5hex_bytes,data,size):
+    table=bytearray(288); table[:32]=md5hex_bytes
+    temp=[le64(table,i*8) for i in range(4)]; b0,b8=temp[0],temp[1]; queue=[temp[2],temp[3]]+[0]*0x22
+    for i in range(0x22):
+        x9,x8=b0,b8; x8=(ror64(x8,8)+x9)&MASK; x8 ^= i; queue[2+i]=x8; x8 ^= ror64(x9,61); writeUint64LE(table,i+1,x8); b0,b8=x8,queue[i]
+    inp=_pad(data,size); return b''.join(_encrypt_input(table,inp[i:i+16]) for i in range(0,len(inp),16))
+def encrypt(khronos,licenseID,aid,randomBytes=None):
+    randomBytes=bytes(randomBytes) if randomBytes is not None else secrets.token_bytes(4)
+    data=f'{khronos}-{licenseID}-{aid}'.encode(); keygen=randomBytes[:4]+str(aid).encode(); mh=md5hexFromBytes(keygen).encode()
+    return base64.b64encode(randomBytes[:4]+encryptLadon(mh,data,len(data))).decode()

tiksignv1-0.1.0/MiniJson.py

@@ -0,0 +1,7 @@
+import json
+def parse(s): return json.loads(s)
+def asObject(o): return o
+def asArray(o): return o
+def optString(m,key): return None if m.get(key) is None else str(m[key])
+def optInt(m,key): return None if m.get(key) is None else int(m[key])
+def optLong(m,key): return None if m.get(key) is None else int(m[key])

tiksignv1-0.1.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: tiksignV1
+Version: 0.1.0
+Summary: Python port of the TikTok signature algorithms from the referenced Java project
+Author: S1 / JokerPython3 Java-port contributors
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=41
+
+# TikTokSignatrueForJava — Python port
+
+This directory is a Python conversion of the Java files in `src/main/java/tiktoksignature` from the referenced repository. It preserves the six-result signing API and the deterministic override fields used by the original test vectors.
+
+## Install
+
+```bash
+python -m pip install -r requirements.txt
+```
+
+## Usage
+
+```python
+from tiktoksignature import Param, SignRequest, SignOptions, sign
+
+request = SignRequest(
+    params=[Param("device_id", "7442000000000000001"), Param("version_name", "41.9.3")],
+    data=[Param("type", "3736")],
+)
+options = SignOptions(version=8404)
+signatures = sign(request, options)
+print(signatures.as_headers)
+```
+
+`SignRequest` accepts ordered `Param` sequences for `params`, `data`, `payload`, and `cookie`. `rawBody` can be used to supply a body string verbatim. For reproducible tests, set `timestamp`, `gorgonByte3`, `gorgonByte7`, `argusRand`, and `ladonRandom` in `SignOptions`.
+
+## Validation
+
+The included `test_vectors.py` compares all six outputs against the nine golden vectors from the Java repository:
+
+```bash
+PYTHONPATH=. python -m tiktoksignature.test_vectors /path/to/TikTokSignatrueForJava/testdata
+```
+
+All nine vectors pass in this conversion.
+
+## Modules
+
+The Java files were converted to corresponding Python modules: `Argus.py`, `CryptoHelpers.py`, `Gorgon.py`, `Ladon.py`, `MiniJson.py`, `Param.py`, `ProtoBuf.py`, `SM3.py`, `SignOptions.py`, `SignRequest.py`, `Signatures.py`, `Signer.py`, `Simon.py`, and `UrlEncode.py`.
+
+The implementation is intended for authorized testing and interoperability only. Keep generated signatures, cookies, and device identifiers private.

tiksignv1-0.1.0/Param.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class Param:
+    key: str
+    value: str

tiksignv1-0.1.0/ProtoBuf.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+KIND_VARINT, KIND_STRING = 0, 2
+@dataclass
+class Field:
+    idx: int; kind: int; varint: int = 0; data: bytes = None
+    @staticmethod
+    def varint_field(idx, value): return Field(idx, KIND_VARINT, value)
+    @staticmethod
+    def string(idx, data): return Field(idx, KIND_STRING, data=data)
+def writeVarint(vint):
+    out=bytearray(); vint &= 0xffffffff
+    while vint > 0x80:
+        out.append((vint & 0x7f)|0x80); vint >>= 7
+    out.append(vint & 0x7f); return bytes(out)
+def serialize(fields):
+    out=bytearray()
+    for f in fields:
+        out += writeVarint((f.idx << 3) | (f.kind & 7))
+        if f.kind == KIND_VARINT: out += writeVarint(f.varint)
+        elif f.kind == KIND_STRING: out += writeVarint(len(f.data)) + f.data
+    return bytes(out)

tiksignv1-0.1.0/README.md

@@ -0,0 +1,41 @@
+# TikTokSignatrueForJava — Python port
+
+This directory is a Python conversion of the Java files in `src/main/java/tiktoksignature` from the referenced repository. It preserves the six-result signing API and the deterministic override fields used by the original test vectors.
+
+## Install
+
+```bash
+python -m pip install -r requirements.txt
+```
+
+## Usage
+
+```python
+from tiktoksignature import Param, SignRequest, SignOptions, sign
+
+request = SignRequest(
+    params=[Param("device_id", "7442000000000000001"), Param("version_name", "41.9.3")],
+    data=[Param("type", "3736")],
+)
+options = SignOptions(version=8404)
+signatures = sign(request, options)
+print(signatures.as_headers)
+```
+
+`SignRequest` accepts ordered `Param` sequences for `params`, `data`, `payload`, and `cookie`. `rawBody` can be used to supply a body string verbatim. For reproducible tests, set `timestamp`, `gorgonByte3`, `gorgonByte7`, `argusRand`, and `ladonRandom` in `SignOptions`.
+
+## Validation
+
+The included `test_vectors.py` compares all six outputs against the nine golden vectors from the Java repository:
+
+```bash
+PYTHONPATH=. python -m tiktoksignature.test_vectors /path/to/TikTokSignatrueForJava/testdata
+```
+
+All nine vectors pass in this conversion.
+
+## Modules
+
+The Java files were converted to corresponding Python modules: `Argus.py`, `CryptoHelpers.py`, `Gorgon.py`, `Ladon.py`, `MiniJson.py`, `Param.py`, `ProtoBuf.py`, `SM3.py`, `SignOptions.py`, `SignRequest.py`, `Signatures.py`, `Signer.py`, `Simon.py`, and `UrlEncode.py`.
+
+The implementation is intended for authorized testing and interoperability only. Keep generated signatures, cookies, and device identifiers private.

tiksignv1-0.1.0/SM3.py

@@ -0,0 +1,25 @@
+import struct
+IV=[0x7380166F,0x4914B2B9,0x172442D7,0xDA8A0600,0xA96F30BC,0x163138AA,0xE38DEE4D,0xB0FB0E4E]
+TJ=[0x79CC4519]*16+[0x7A879D8A]*48
+MASK=0xffffffff
+def rotl(x,n): return ((x << (n%32)) | (x >> (32-n%32))) & MASK if n%32 else x & MASK
+def p0(x): return x ^ rotl(x,9) ^ rotl(x,17)
+def p1(x): return x ^ rotl(x,15) ^ rotl(x,23)
+def hash(msg):
+    if isinstance(msg,str): msg=msg.encode()
+    m=bytearray(msg); m.append(0x80)
+    while len(m)%64 != 56: m.append(0)
+    m += struct.pack('>Q',len(msg)*8); v=IV[:]
+    for off in range(0,len(m),64):
+        w=list(struct.unpack('>16I',m[off:off+64]))
+        for j in range(16,68): w.append((p1(w[j-16]^w[j-9]^rotl(w[j-3],15))^rotl(w[j-13],7)^w[j-6])&MASK)
+        w1=[w[j]^w[j+4] for j in range(64)]
+        a,b,c,d,e,f,g,h=v
+        for j in range(64):
+            ff=(a^b^c) if j<16 else ((a&b)|(a&c)|(b&c))
+            gg=(e^f^g) if j<16 else ((e&f)|((~e)&g))
+            ss1=rotl((rotl(a,12)+e+rotl(TJ[j],j))&MASK,7); ss2=ss1^rotl(a,12)
+            tt1=(ff+d+ss2+w1[j])&MASK; tt2=(gg+h+ss1+w[j])&MASK
+            d,c,b,a=c,rotl(b,9),a,tt1; h,g,f,e=g,rotl(f,19),e,p0(tt2)&MASK
+        v=[(x^y)&MASK for x,y in zip(v,(a,b,c,d,e,f,g,h))]
+    return struct.pack('>8I',*v)

tiksignv1-0.1.0/SignOptions.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from typing import Optional
+
+@dataclass
+class SignOptions:
+    timestamp: Optional[int] = None
+    aid: int = 0
+    licenseID: int = 0
+    platform: int = 0
+    sdkVersion: Optional[str] = None
+    sdkVersionInt: int = 0
+    version: int = 0
+    secDeviceID: Optional[str] = None
+    gorgonByte3: Optional[int] = None
+    gorgonByte7: Optional[int] = None
+    argusRand: Optional[int] = None
+    ladonRandom: Optional[bytes] = None

tiksignv1-0.1.0/SignRequest.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass
+from typing import Optional, Sequence
+from .Param import Param
+
+@dataclass
+class SignRequest:
+    url: Optional[str] = None
+    params: Optional[Sequence[Param]] = None
+    data: Optional[Sequence[Param]] = None
+    payload: Optional[Sequence[Param]] = None
+    cookie: Optional[Sequence[Param]] = None
+    rawBody: Optional[str] = None

tiksignv1-0.1.0/Signatures.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class Signatures:
+    xArgus: str
+    xLadon: str
+    xGorgon: str
+    xKhronos: str
+    xTTRequestTicket: str
+    xSSStub: str
+
+    @property
+    def as_headers(self):
+        return {
+            'X-Argus': self.xArgus, 'X-Ladon': self.xLadon,
+            'X-Gorgon': self.xGorgon, 'X-Khronos': self.xKhronos,
+            'X-TT-Request-Ticket': self.xTTRequestTicket,
+            'X-SS-Stub': self.xSSStub,
+        }

tiksignv1-0.1.0/Signer.py

@@ -0,0 +1,32 @@
+import secrets, time
+from .Param import Param
+from .Signatures import Signatures
+from . import UrlEncode, Gorgon, Argus, Ladon
+
+def paramsFromURL(url):
+    query=url.split('?',1)[1] if '?' in url else ''; out=[]; seen={}
+    for p in query.split('&') if query else []:
+        k,v=(p.split('=',1)+[''])[:2] if '=' in p else (p,'')
+        if k in seen: out[seen[k]]=Param(k,v)
+        else: seen[k]=len(out); out.append(Param(k,v))
+    return out
+
+def sign(req, opts):
+    aid=opts.aid or 1233; licenseID=opts.licenseID or 1611921764; sdkstr=opts.sdkVersion or 'v05.00.06-ov-android'; sdkint=opts.sdkVersionInt or 167775296; unix=opts.timestamp if opts.timestamp is not None else int(time.time())
+    payload=list(req.payload or []); data=list(req.data or [])
+    if not data and payload: data=payload
+    elif not payload and data: payload=data
+    params=list(req.params) if req.params is not None else paramsFromURL(req.url) if req.url else []; cookie=list(req.cookie or [])
+    payloadStr=UrlEncode.encodeParams(payload); paramsStr=UrlEncode.encodeParams(params); cookieStr=UrlEncode.encodeParams(cookie); dataStr=req.rawBody if req.rawBody is not None and req.rawBody != '' else UrlEncode.encodeParams(data)
+    stub=__import__('hashlib').md5(dataStr.encode()).hexdigest(); version=opts.version
+    if version==8404:
+        b3=opts.gorgonByte3 if opts.gorgonByte3 is not None else secrets.randbelow(256); b7=opts.gorgonByte7 if opts.gorgonByte7 is not None else secrets.randbelow(256); ticket,khronos,gorgon=Gorgon.v1(paramsStr,payloadStr,cookieStr,unix,b3,b7)
+    elif version==8402: ticket,khronos,gorgon=Gorgon.v2(paramsStr,payloadStr,cookieStr,unix)
+    elif version in (0,4404): ticket,khronos,gorgon=Gorgon.v3(paramsStr,payloadStr,cookieStr,unix)
+    else: raise ValueError(f'unsupported gorgon version {version}')
+    sec=opts.secDeviceID or ('AadCFwpTyztA5j9L'+''.join('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'[x%62] for x in secrets.token_bytes(9)))
+    argus=Argus.getSign(paramsStr,stub,unix,aid,licenseID,opts.platform,sec,sdkstr,sdkint,opts.argusRand)
+    ladon=Ladon.encrypt(unix,licenseID,aid,opts.ladonRandom)
+    return Signatures(argus,ladon,gorgon,khronos,ticket,stub.upper())
+class Signer:
+    sign=staticmethod(sign)

tiksignv1-0.1.0/Simon.py

@@ -0,0 +1,13 @@
+MASK=0xffffffffffffffff
+Z=0x3DC94C3A046D678B
+def rol(v,n): return ((v<<n)|(v>>(64-n))) & MASK
+def ror(v,n): return ((v>>n)|(v<<(64-n))) & MASK
+def encrypt(pt,k):
+    key=list(k)+[0]*68
+    for i in range(4,72):
+        tmp=ror(key[i-1],3)^key[i-3]; tmp ^= ror(tmp,1)
+        key[i]=((~key[i-4])^tmp^((Z>>((i-4)%62))&1)^3)&MASK
+    x,y=pt
+    for i in range(72):
+        x,y=y,(x^(rol(y,1)&rol(y,8))^rol(y,2)^key[i])&MASK
+    return x,y

tiksignv1-0.1.0/UrlEncode.py

@@ -0,0 +1,20 @@
+from urllib.parse import quote_plus as _quote_plus
+from .Param import Param
+
+def quotePlus(s): return _quote_plus(str(s), safe='-_.~')
+def unquotePlus(s):
+    from urllib.parse import unquote_plus
+    return unquote_plus(s)
+def encodeParams(pairs):
+    return '' if pairs is None else '&'.join(f'{quotePlus(p.key)}={quotePlus(p.value)}' for p in pairs)
+def parseQueryParams(qs):
+    out = {}
+    if not qs: return out
+    for chunk in qs.split('&'):
+        for pair in chunk.split(';'):
+            if not pair or '=' not in pair: continue
+            name, value = pair.split('=', 1)
+            if not value: continue
+            name, value = unquotePlus(name), unquotePlus(value)
+            if name not in out: out[name] = value
+    return out

tiksignv1-0.1.0/__init__.py

@@ -0,0 +1,6 @@
+from .Param import Param
+from .SignRequest import SignRequest
+from .SignOptions import SignOptions
+from .Signatures import Signatures
+from .Signer import sign, Signer
+__all__=['Param','SignRequest','SignOptions','Signatures','sign','Signer']

tiksignv1-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tiksignV1"
+version = "0.1.0"
+description = "Python port of the TikTok signature algorithms from the referenced Java project"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [{name = "S1 / JokerPython3 Java-port contributors"}]
+license = {text = "MIT"}
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Security :: Cryptography",
+]
+dependencies = ["cryptography>=41"]
+
+[tool.setuptools]
+packages = ["tiktoksignature"]
+
+[tool.setuptools.package-dir]
+tiktoksignature = "."
+
+[tool.setuptools.exclude-package-data]
+"*" = ["testdata/*", "__pycache__/*", "*.pyc"]

tiksignv1-0.1.0/setup.cfg

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

tiksignv1-0.1.0/test_vectors.py

@@ -0,0 +1,10 @@
+import json, pathlib, sys
+from tiktoksignature import Param, SignRequest, SignOptions, sign
+root=pathlib.Path(sys.argv[1] if len(sys.argv)>1 else '../tiktoksig/testdata')
+for path in sorted(root.glob('vector_*.json')):
+    d=json.loads(path.read_text()); i=d['input']; pairs=lambda x: None if x is None else [Param(*p) for p in x]
+    req=SignRequest(params=pairs(i.get('params')),data=pairs(i.get('data')),payload=pairs(i.get('payload')),cookie=pairs(i.get('cookie')),rawBody=i.get('raw_body'))
+    o=SignOptions(timestamp=i.get('timestamp'),aid=i.get('aid',0),licenseID=i.get('license_id',0),platform=i.get('platform',0),sdkVersion=i.get('sdk_version_str'),sdkVersionInt=i.get('sdk_version',0),version=i.get('version') or 0,secDeviceID=i.get('sec_device_id'),gorgonByte3=d.get('random',{}).get('gorgon_byte3'),gorgonByte7=d.get('random',{}).get('gorgon_byte7'),argusRand=d.get('random',{}).get('argus_rand'),ladonRandom=bytes.fromhex(d.get('random',{}).get('ladon_random','')) if d.get('random',{}).get('ladon_random') else None)
+    got=sign(req,o); exp=d['expected']; actual={'x_argus':got.xArgus,'x_ladon':got.xLadon,'x_gorgon':got.xGorgon,'x_khronos':got.xKhronos,'x_tt_request_ticket':got.xTTRequestTicket,'x_ss_stub':got.xSSStub}
+    assert actual==exp, f'{path.name} mismatch\nexpected={exp}\nactual={actual}'
+    print('PASS',path.name)

tiksignv1-0.1.0/tiksignV1.egg-info/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: tiksignV1
+Version: 0.1.0
+Summary: Python port of the TikTok signature algorithms from the referenced Java project
+Author: S1 / JokerPython3 Java-port contributors
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=41
+
+# TikTokSignatrueForJava — Python port
+
+This directory is a Python conversion of the Java files in `src/main/java/tiktoksignature` from the referenced repository. It preserves the six-result signing API and the deterministic override fields used by the original test vectors.
+
+## Install
+
+```bash
+python -m pip install -r requirements.txt
+```
+
+## Usage
+
+```python
+from tiktoksignature import Param, SignRequest, SignOptions, sign
+
+request = SignRequest(
+    params=[Param("device_id", "7442000000000000001"), Param("version_name", "41.9.3")],
+    data=[Param("type", "3736")],
+)
+options = SignOptions(version=8404)
+signatures = sign(request, options)
+print(signatures.as_headers)
+```
+
+`SignRequest` accepts ordered `Param` sequences for `params`, `data`, `payload`, and `cookie`. `rawBody` can be used to supply a body string verbatim. For reproducible tests, set `timestamp`, `gorgonByte3`, `gorgonByte7`, `argusRand`, and `ladonRandom` in `SignOptions`.
+
+## Validation
+
+The included `test_vectors.py` compares all six outputs against the nine golden vectors from the Java repository:
+
+```bash
+PYTHONPATH=. python -m tiktoksignature.test_vectors /path/to/TikTokSignatrueForJava/testdata
+```
+
+All nine vectors pass in this conversion.
+
+## Modules
+
+The Java files were converted to corresponding Python modules: `Argus.py`, `CryptoHelpers.py`, `Gorgon.py`, `Ladon.py`, `MiniJson.py`, `Param.py`, `ProtoBuf.py`, `SM3.py`, `SignOptions.py`, `SignRequest.py`, `Signatures.py`, `Signer.py`, `Simon.py`, and `UrlEncode.py`.
+
+The implementation is intended for authorized testing and interoperability only. Keep generated signatures, cookies, and device identifiers private.

tiksignv1-0.1.0/tiksignV1.egg-info/SOURCES.txt

@@ -0,0 +1,39 @@
+Argus.py
+CryptoHelpers.py
+Gorgon.py
+Ladon.py
+MiniJson.py
+Param.py
+ProtoBuf.py
+README.md
+SM3.py
+SignOptions.py
+SignRequest.py
+Signatures.py
+Signer.py
+Simon.py
+UrlEncode.py
+__init__.py
+pyproject.toml
+test_vectors.py
+./Argus.py
+./CryptoHelpers.py
+./Gorgon.py
+./Ladon.py
+./MiniJson.py
+./Param.py
+./ProtoBuf.py
+./SM3.py
+./SignOptions.py
+./SignRequest.py
+./Signatures.py
+./Signer.py
+./Simon.py
+./UrlEncode.py
+./__init__.py
+./test_vectors.py
+tiksignV1.egg-info/PKG-INFO
+tiksignV1.egg-info/SOURCES.txt
+tiksignV1.egg-info/dependency_links.txt
+tiksignV1.egg-info/requires.txt
+tiksignV1.egg-info/top_level.txt

tiksignv1-0.1.0/tiksignV1.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tiksignv1-0.1.0/tiksignV1.egg-info/requires.txt

@@ -0,0 +1 @@
+cryptography>=41

tiksignv1-0.1.0/tiksignV1.egg-info/top_level.txt

@@ -0,0 +1 @@
+tiktoksignature