Signs clientinit with the account's Ed25519 key over the connection challenge, honours the per-bookmark switch, sends updatemytsid on sign-in/out, and connects without the ID when myTeamSpeak is unreachable. Verified live against server.lixko.eu. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
14 KiB
Announcing the myTeamSpeak ID to a server
What the client has to send so that a server shows our client_myteamspeak_id, the way the
official client does when a bookmark has "Enable myTeamSpeak features" on. Observed with TS3 3.6.2
signed in to the throwaway account against the test server, 2026-10-10.
RE status: both missing inputs are now recovered and checked offline. The private scalar unwrap matches the captured account public key; the challenge derivation was exercised in the actual desktop machine code under Unicorn. Application integration is implemented (see below) and verified live against server.lixko.eu (2026-10-10). Reproduction programs are linked below.
The switch
Connect dialog and bookmarks: "Enable myTeamSpeak features", on by default. It is
Bookmark_Data.send_mytsid_on_server (22) in the sync schema. When it is on and the client is
signed in, clientinit carries the extra parameters below. client_myteamspeak_id itself is
sent empty; the server fills it in from them and announces it to everyone
(notifycliententerview client_myteamspeak_id=<base64>).
The official client also has a post-connect updatemytsid command, which takes the same data,
for signing in or out while connected. It was not hit during a normal connect.
Extra clientinit parameters
| Parameter | Value | Source |
|---|---|---|
myTeamspeakId |
base64 of the 33-byte myTeamSpeak ID (01 20 …) |
known: login myts_id_data.my_teamspeak_id (4) |
acTime |
account creation time as a u64, byte-swapped, in decimal | known: login myts_id_data.account_creation_time (3) |
userPubKey |
base64, 32 bytes (Ed25519 public key) | known: login myts_id_data.user_public_key (1) |
pubSign |
base64, 64 bytes | known: first 64 bytes of login myts_id_data.public_signature (5) |
pubSignCert |
base64, 112 bytes (certificate naming "TeamSpeak Systems GmbH") | known: remaining 112 bytes of public_signature (5) |
authSign |
base64, 64 bytes | raw-scalar Ed25519 over `SHA256(30 08 00 00 00 00 |
acTime example: creation time 1790376353 = 0x6AB6F9A1; as big-endian u64
a1f9b66a00000000 = 11671560475690139648.
authSign — reverse-engineered (static, 2026-10-10)
authSign is an Ed25519 signature (64 bytes = R||S, base64) by the account's user key over a
per-connection message. It is made fresh per connection because the message embeds a
connection-derived challenge, so replaying an old one does not work.
Where it is built
All six clientinit/updatemytsid parameters are assembled by one function (call it
buildMytsidParams) in the Android libteamspeak_client.so (x86-64) at vaddr 0x813b40, called
from 3 sites (0x81bda4, 0x81e677, 0x84f2c8 — the clientinit and updatemytsid paths). The desktop
ts3client_linux_amd64 carries the same code (same strings + SHA-512 K-table). Its args:
arg0(rdi) = the user keypair object. Two 32-bytestd::stringmembers:+0x20= public keyA,+0x38= raw secret scalara. In the callers this object is at[conn+0x218].arg1(rsi) = the command/parameter map (values inserted via the helper at 0x8b1870).arg2(rdx) = a reference to a shared pointer to the connection crypto object, obtained through the manager'svtable+0x70. It is not a string. The builder obtains packet-key material from this object to constructC; see the corrected desktop trace below.
myTeamspeakId, acTime, userPubKey, pubSign, pubSignCert are just base64 of fields of the
MyTeamSpeakIdData struct (offsets 0, +0x18, +0x20, +0x50, +0x68). authSign is the odd one out:
its value is base64(sig) where sig is produced by the signer at 0x94a2a0 over the message
M = C || "MyTeamSpeakID" (the literal is appended to the challenge before signing).
The signer (0x94a2a0) — deterministic Ed25519 over SHA-512
Reconstructed (hash factory 0x9430e0 with selector 1 = SHA-512; R=r·B via 0x94ee80;
reduce mod L via 0x94a7b0; S=r+k·a via 0x94b310):
r = SHA512(a || M) mod L # deterministic nonce, seeded by the raw scalar a
R = r · B # 32-byte encoded point -> sig[0:32]
k = SHA512(R || A || M) mod L
S = (r + k · a) mod L # -> sig[32:64]
authSign = base64(R || S)
Because R = r·B and A = a·B, this is a standard, stock-verifiable Ed25519 signature over M
under public key A — the server almost certainly just runs ed25519_verify(authSign, M, A).
The signature equation is standard Ed25519, although nonce derivation and secret-key format differ
from RFC 8032. A standard verifier accepts this construction. We can reproduce the exact nonce
using the existing ref10 arithmetic; there is no need to rely on untested alternative nonces.
Correction: Bouncy Castle's public low-level signing overloads also take a seed. Passing a
as that seed hashes and clamps it again and gives the wrong key. Its raw-scalar signing internals
are private; stock TweetNaCl's signing entry point is seed-based too.
Dynamic capture — scheme CONFIRMED live (2026-10-10)
Ran the official TS3 3.6.2 client under Xvfb (GLIBC_TUNABLES=glibc.pthread.rseq=0 to stop a
mutex lock failed crash on new glibc; the xcb/libpci lib shim set from the prior harness), signed
in to the throwaway myTeamSpeak account, and connected to server.lixko.eu:9987 with "Enable
myTeamSpeak features" on. gdb attached as root (yama scope=1 → sudo gdb), breakpoint at the signer.
The server accepted the real authSign ("Connection established"), so the model below is the live
protocol, not a guess.
Desktop addresses (PIE; add the load bias): signer 0x1196800 (= Android 0x94a2a0),
buildMytsidParams 0x1018580, its clientinit caller 0x1020c3b. At the signer: rcx=A,
r8=a, rsi/rdx=M, rdi=out(R||S).
Ground truth (throwaway account)
a (secret scalar) = e02e4e5f22623f82389e469e56290ac046c13f7ecc6fde99d17360d1f4bfd67a
A (public key) = 4ffcab6e0aeefbcbc0b4bbbe25b7e36c171016f73a65c3a71dd4bb5a9f5dab8e
M = C || "MyTeamSpeakID" (C = 32 bytes, then the 13-byte ASCII literal; rdx = 45)
Verified offline (pure-Python Ed25519 + cryptography): A == a·B (so a is the raw Ed25519
scalar, A the public key), and the deterministic scheme above produces a signature that passes
stock Ed25519PublicKey(A).verify(sig, M). This confirms compatibility with stock Ed25519
verification, not the server's exact implementation. A is the userPubKey/user_public_key
param (it is NOT the 31-byte body of the myTeamspeakId).
C recovered: packet key + nonce for type 8, server direction, generation 0
For the captured AES-128/SHA-256 connection mode:
sharedIV = SHA512(encoded_Ed25519_DH_point) XOR (alpha[10] || beta[54])
C = SHA256(hex("30 08 00 00 00 00") || sharedIV)
M = C || ASCII("MyTeamSpeakID") # exactly 45 bytes, no NUL terminator
sharedIV is precisely ts3j's SecureChannelParameters.ivStruct / the value passed into
PacketTransformation. It is not the raw shared secret. 30 is the server-direction tag,
08 is packet type 8, and the four zeros are the big-endian generation counter. Packet ID is
also zero, so the usual XOR of the first two key bytes changes nothing. Equivalently, obtain
key || nonce from PacketTransformation.computeParameters with a SERVER header of type 8,
generation 0 and packet ID 0. Do not use the CLIENT direction merely because we are the client.
Corrected desktop trace (all addresses are PIE-relative):
| Address | Evidence |
|---|---|
0x1020c05 |
manager virtual call returns a shared pointer at rsp+0x88 |
0x105a270 → 0x105ed30 |
selects enum key 1 in map at manager +0x110; returns two pointers and increments reference count, not a std::string |
0x1018a57–0x1018a6f |
dereferences that shared pointer; calls 0xff4770(out, crypto, 0, 0, 8, 0) |
0xff496d–0xff4a89 |
builds direction/type/generation prefix 30 08 00 00 00 00 |
0xff4a92–0xff4b77 |
appends bytes from crypto +0x1b8, 64 bytes for handshake mode 2/3, otherwise 20 |
0xff4ba9 |
calls LibTomCrypt hash_memory with the configured hash selector |
0xfef971–0xfef97d |
cipher mode 0 selects the literal sha256; mode 1 selects sha512 at 0xfef953 |
0xff4ed8–0xff4ee9 |
XORs packet ID into the key's first two bytes (zero here) |
0x1018acc–0x1018bcb |
copies and concatenates key and nonce (16+16 bytes in mode 0; 32+32 in mode 1) |
0x1018ce3–0x1018cfb |
appends the 13-byte literal before signing |
The sharedIV buffer is XORed with the handshake secret at 0xff2a08 (64 bytes) through
0x129b9d0, an in-place XOR helper. The same buffer feeds ordinary packet key derivation.
This explains why searching the manager's inline memory for plain SHA-256 preimages failed:
the buffer is in a different object and the hash has a six-byte prefix.
The previous captures of different C values remain useful, but C.bin/C_obj.bin from the
old string-decoding harness are not reliable challenge dumps: those interpreted a shared pointer
as a libc++ string. The signer message captures (msg*.bin) are the reliable C || literal bytes.
The native code also supports a SHA-512, 32-byte key + 32-byte nonce mode; its binder would be 64 bytes and message 77 bytes. The observed session and current ts3j packet cipher use mode 0. Do not generalize the 32-byte challenge to every possible negotiated cipher mode.
Scalar unwrap recovered and verified
accountKey = PBKDF2_HMAC_SHA512(password, lower(email)+"ts3Encryption"+password, 10000, 32)
itemKey = MyTsCrypto.unwrapItemKey(accountKey, LoginSession.key)
a = MyTsCrypto.decryptItem(encrypted_user_private_key, itemKey)
assert len(a) == 32
assert encode(a * B) == user_public_key
The 112-byte blob is the existing item frame: IV[16] || ciphertext[32] || SHA512(a)[64],
AES-256-CTR with little-endian counter increments. No additional KDF or scalar clamping occurs
after decryption. The captured blob passes the digest check and produces exactly the live
scalar above. Deriving a public key from that value as a Bouncy Castle seed produces a different
public key, independently confirming the distinction.
Library choice and reproducible checks
Use existing JCA MyTsCrypto for key unwrap and existing ts3j ref10 primitives for signing:
ScalarOperations.sc_reduce, GroupOperations.ge_scalarmult_base,
GroupOperations.ge_p3_tobytes, and ScalarOperations.sc_muladd. The thin signing adapter is
in MyTsAuthCheck.java; it implements the formula above without new curve
arithmetic. Punisher.NaCl.Ed25519.Sign itself is also seed-based despite its parameter being
called expandedPrivateKey, so do not call it with a || A.
Bouncy Castle 1.86 can verify these signatures directly. Its public signer cannot sign from the
raw scalar; upstream Ed25519 source
keeps the scalar-based implSign and base-point helpers private. Reflection into these internals
is unnecessary. This is plain Ed25519 verification, not Ed25519ph or Ed25519ctx; the literal is
part of the message, not an RFC 8032 context parameter.
From the workspace root, with ts3j compiled and BC 1.86 in the local Maven cache:
python3 ts3-client/docs/myteamspeak/check_native_challenge.py TeamSpeak3-Client-linux_amd64/ts3client_linux_amd64
mkdir -p /tmp/myts-auth-check
auth_cp="ts3j/target/classes:$HOME/.m2/repository/org/bouncycastle/bcprov-jdk18on/1.86/bcprov-jdk18on-1.86.jar"
javac -cp "$auth_cp" -d /tmp/myts-auth-check ts3-client/core/src/main/java/eu/lixko/ts3j/client/myts/MyTsCrypto.java ts3-client/docs/myteamspeak/MyTsAuthCheck.java
java -cp "/tmp/myts-auth-check:$auth_cp" eu.lixko.ts3j.client.myts.MyTsAuthCheck
The Python check requires Unicorn and executes the actual native packet-key routine with synthetic
sharedIV 00 01 … 3f, stopping at the hash call. It asserts the exact hash input and checks the
native hash-name literals. Expected challenge:
d178cabdc4faa5bb033b175d2f691564975d38b48994ab8eaf93ee88f1bb73f8.
The Java check verifies the captured private-key unwrap/public-key relation, rejects the seed
interpretation, signs the synthetic challenge using existing arithmetic, verifies with stock BC,
and confirms that changing the challenge invalidates the signature. All checks passed.
Live check (2026-10-10, server.lixko.eu, throwaway account): our clientinit with the six
parameters makes the server report client_myteamspeak_id; without them it is absent; an
updatemytsid with empty values clears it and a freshly signed one sets it again, also on a
connection that started without it. A clientinit with one bit of authSign flipped still
connects but the server silently drops the ID, so the signature is checked.
Production integration now lives in MyTeamSpeakIdentity, MyTeamSpeakLogin.serverIdentity,
and ts3j's addMyTeamSpeakParameters. Desktop and Android provide the signed-in account to
the connection, honor the bookmark switch, and send updatemytsid on account changes.
The scalar is cached only in memory and wiped on sign-out/account replacement. The Connect
dialog also offers the feature switch. Automated tests cover the parser, signature, connection
binding, saved sign-in, and revocation.
Capture harness notes (reusable)
- Official client:
GLIBC_TUNABLES=glibc.pthread.rseq=0,LD_LIBRARY_PATH+= the xcb/libpci shim dir,HOME=throwaway profile, under Xvfb. License + "stay logged in" persist insettings.db, so only the first run needs the EULA/login clicks. - Do not
kill -9gdb while it holds the inferior stopped — it crashes the client. Make the gdb scriptdetach+quititself after the capture, orkill -INT. std::string(libc++): flag byte at +0; long ifflag&1→ size at +8, data ptr at +16; else short → sizeflag>>1, data at +1.
Verification once it is known
- Connect our client with the switch on, signed in to the throwaway account.
- From a second client (the ts3j probe bot), check that
notifycliententerviewcarriesclient_myteamspeak_id=ASCwXERY29umCjNyMewplck8cVzzMx/Xsh8vab8V7grN, the throwaway's ID. - Check that with the switch off the field stays empty.