decode.js

/**
 * ⚠️ PRIVACY RESEARCH USE ONLY
 * For authorized testing environments that comply with all applicable laws.
 * See: https://github.com/botswin/qrator-Privacy-Research/blob/main/DISCLAIMER.md
 */

// @ts-check

const assert = require('assert');
const crypto = require('crypto');

/**
 * hpFrom: Same as in encode – encode a JS string into a Buffer via UTF-8.
 *
 * @param {string} s - Input string.
 * @returns {Buffer} - Buffer of UTF-8 bytes.
 */
function hpFrom(s) {
    const encoder = new TextEncoder();
    const uint8 = encoder.encode(s);
    return Buffer.from(uint8);
}

/**
 * Kt: Same as in encode – percent-encode non-ASCII, then XOR with r (key).
 *
 * @param {string} t - Input string (should be percent-encoded already).
 * @param {string} r - Key string used for XOR.
 * @returns {string} - XORed result.
 */
function Kt(t, r) {
    const c = r.length;
    let W = '';
    t.split('').map((ch) => {
        const n = ch.charCodeAt(0);
        if (n > 127) {
            let hex = n.toString(16);
            const i = hex.length;
            for (let u = 0; u < 4 - i; u++) {
                hex = '0' + hex;
            }
            W += '%' + hex;
        } else {
            W += ch;
        }
    });
    return W.split('')
        .map((ch, idx) => {
            return String.fromCharCode(ch.charCodeAt(0) ^ r[idx % c].charCodeAt(0));
        })
        .join('');
}

/**
 * Ot: Same as in encode – convert JS string into array of 32-bit words.
 *
 * @param {string} t - Input string.
 * @returns {number[]} - Array of 32-bit words.
 */
function Ot(t) {
    const nArray = [];
    // Initialize array length: (t.length >> 2)
    nArray[(t.length >> 2) - 1] = undefined;
    for (let i = 0; i < nArray.length; i++) {
        nArray[i] = 0;
    }
    const e = 8 * t.length;
    for (let r = 0; r < e; r += 8) {
        nArray[r >> 5] |= (255 & t.charCodeAt(r / 8)) << r % 32;
    }
    return nArray;
}

/**
 * yt: Same as in encode – take array of 32-bit words (t) and bit-length (r),
 * compute MD5-based mixing, and return new array of 32-bit words [A,B,C,D].
 *
 * @param {number[]} t - Array of 32-bit words.
 * @param {number} r - Bit-length (e.g. 8 * original string length, or 512 + ...).
 * @returns {number[]} - Array of four 32-bit unsigned integers.
 */
function yt(t, r) {
    const byteCount = Math.floor(r / 8);
    const fullBytes = Buffer.alloc(t.length * 4);
    for (let i = 0; i < t.length; i++) {
        const word = t[i] >>> 0;
        fullBytes[i * 4 + 0] = word & 0xff;
        fullBytes[i * 4 + 1] = (word >>> 8) & 0xff;
        fullBytes[i * 4 + 2] = (word >>> 16) & 0xff;
        fullBytes[i * 4 + 3] = (word >>> 24) & 0xff;
    }

    const originalBytes = fullBytes.slice(0, byteCount);
    const md5Digest = crypto.createHash('md5').update(originalBytes).digest();
    const A = md5Digest.readUInt32LE(0);
    const B = md5Digest.readUInt32LE(4);
    const C = md5Digest.readUInt32LE(8);
    const D = md5Digest.readUInt32LE(12);

    return [A, B, C, D];
}

/**
 * gt: Same as in encode – implements HMAC-MD5-like routine.
 *
 * @param {string} t - Input text.
 * @param {string} r - Input key.
 * @returns {string} - Result as raw binary string (not hex).
 */
function gt(t, r) {
    const o = Ot(t);
    let oCut = o;
    // If o longer than 16 words, reduce
    if (o.length > 16) {
        oCut = yt(o, 8 * t.length);
    }
    const cArr = [];
    const WArr = [];
    // Prepare inner and outer pads
    for (let n = 0; n < 16; n++) {
        cArr[n] = 909522486 ^ oCut[n];
        WArr[n] = 1549556828 ^ oCut[n];
    }
    // Compute inner hash
    const eArr = yt(cArr.concat(Ot(r)), 512 + 8 * r.length);
    // Compute outer hash, then pass to Ct
    return Ct(yt(WArr.concat(eArr), 640));
}

/**
 * Ct: Convert array of 32-bit words back into raw JS string (characters per byte).
 *
 * @param {number[]} t - Array of 32-bit words.
 * @returns {string} - Raw string.
 */
function Ct(t) {
    let n = '';
    const e = 32 * t.length;
    for (let r = 0; r < e; r += 8) {
        n += String.fromCharCode((t[r >> 5] >>> r % 32) & 255);
    }
    return n;
}

/**
 * bt: Compute MD5 of input text, return raw string via Ct(yt(...))
 *
 * @param {string} t - Input text.
 * @returns {string} - Raw MD5 result as string.
 */
function bt(t) {
    return Ct(yt(Ot(t), 8 * t.length));
}

/**
 * Rt: Convert raw binary string into hex representation.
 *
 * @param {string} t - Input raw string.
 * @returns {string} - Hex string (lowercase).
 */
function Rt(t) {
    let o = '';
    for (let n = 0; n < t.length; n++) {
        const r = t.charCodeAt(n);
        o += '0123456789abcdef'.charAt((r >>> 4) & 15) + '0123456789abcdef'.charAt(15 & r);
    }
    return o;
}

/**
 * xt: Same as encode's key derivation:
 * If r is provided: if n true, return raw gt(r, t); else return hex of gt(r, t).
 * If r not provided: if n true, return raw bt(t); else return hex of bt(t).
 *
 * @param {string} t - Input text t.
 * @param {string} [r] - Input key r (optional).
 * @param {boolean} [n] - Flag for raw vs hex (optional).
 * @returns {string} - Derived value (hex or raw).
 */
function xt(t, r, n) {
    return r
        ? n
            ? gt(r, t)
            : (function (t, r) {
                  return Rt(gt(t, r));
              })(r, t)
        : n
          ? bt(t)
          : (function (t) {
                return Rt(bt(t));
            })(t);
}

/**
 * parseCookie: Same as in encode – brute-force MD5 until prefix matches.
 *
 * @param {string} cookie - Cookie string containing e + '-' + nonce-hash fragment.
 * @returns {{cookie: string, nonce: number}}
 */
function parseCookie(cookie) {
    const [e, o, cFragment] = cookie.split('-');
    let found = 0;
    for (let W = 1; W < 1e7; W++) {
        const h = crypto
            .createHash('md5')
            .update(e + W)
            .digest('hex');
        if (h.startsWith(cFragment)) {
            found = W;
            break;
        }
    }
    return { cookie: e, nonce: found };
}

/**
 * decryptValue: Reverse of encodeValue.
 *
 * @param {string} encodedValue - e.g. 'v1$67d9$TBNOVgoX...'
 * @param {string} qrator_jsr_cookie - Same cookie that was used in encode.
 * @returns {Object} - The original JS object that was JSON-stringified.
 */
function decryptValue(encodedValue, qrator_jsr_cookie) {
    // 1. Split encodedValue into parts: ['v1', randomValue, base64Data]
    const parts = encodedValue.split('$');
    if (parts.length !== 3 || parts[0] !== 'v1') {
        return encodedValue; // Invalid format, return as is
    }
    const randomValue = parts[1];
    const base64Data = parts[2];

    // 2. Recompute parseCookie to get e and nonce c
    const { cookie: e, nonce: c } = parseCookie(qrator_jsr_cookie);

    // 3. Derive the same hexKey that was used in encode:
    //    t = randomValue + e + c
    const t = '' + randomValue + e + c;
    //    xt(t) without third arg → hex string
    const hexKey = xt(t);

    // 4. Base64→Buffer→UTF8 string to recover XORed result (XORedString)
    const xorBuf = Buffer.from(base64Data, 'base64');
    const xorString = xorBuf.toString('utf8');

    // 5. Reverse the XOR step: produce W (percent-encoded string)
    //    W = for each char in xorString, XOR with hexKey char
    let W = '';
    for (let i = 0; i < xorString.length; i++) {
        const chCode = xorString.charCodeAt(i);
        const keyCode = hexKey.charCodeAt(i % hexKey.length);
        W += String.fromCharCode(chCode ^ keyCode);
    }

    // 6. W now contains ASCII + "%XXXX" sequences for non-ASCII.
    //    We must convert every "%XXXX" into the corresponding Unicode char.
    //    For example, "%00e9" → codepoint 0x00e9 → "é".
    const decoded = W.replace(/%([0-9a-fA-F]{4})/g, (_, hex) => {
        return String.fromCharCode(parseInt(hex, 16));
    });

    // 7. decoded is the original JSON string of the value
    let originalObj;
    try {
        originalObj = JSON.parse(decoded);
    } catch (eParse) {
        throw new Error('Failed to JSON.parse decrypted string: ' + eParse.message);
    }

    return originalObj;
}

// ==============================
// Example usage / self-test
// ==============================
if (require.main === module) {
    // Provided qrator_jsr_cookie and randomValue + value from your example
    const qrator_jsr_cookie =
        'v2.0.1748810466.926.18e18377qIgMovMv|Fs09gz2IRGhcowVM|4CrqtgLCFQAhcZPdtEF4UmcG5qvqM0NDWEgx9sWCJJbUosO7K3tHBJ6YP+almohGILePl+OQ31T1OAKvDJjAyw==-zY1Wuybi/bcIc9dp3TTp+5CBfWI=-00';
    const randomValue = '67d9';
    const value = {
        value: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36',
        time: 1748810468.811,
    };

    function encodeValue(randomValue, qrator_jsr_cookie, value) {
        const i = JSON.stringify(value);
        const { cookie: o, nonce: c } = parseCookie(qrator_jsr_cookie);
        const keyText = '' + randomValue + o + c;
        const base64Encoded = hpFrom(Kt(i, xt(keyText))).toString('base64');
        return 'v1$' + randomValue + '$' + base64Encoded;
    }

    const encodedValue = encodeValue(randomValue, qrator_jsr_cookie, value);
    console.log('Encoded Value (for test):', encodedValue);

    const decrypted = decryptValue(encodedValue, qrator_jsr_cookie);
    console.log('Decrypted Object:', decrypted);

    assert.deepStrictEqual(decrypted, value);
    console.log('✅ Decryption matches original value!');
}

module.exports = {
    parseCookie,
    decryptValue,
};