[bug] Old browsers are not supported instrumental challenge feature

[Colonizator1]

bug description:
Because of this new DecompressionStream("deflate-raw") old browsers can't solve the instrumental challenge

to reproduce:
Any browser with a version lower than the compatibility table https://developer.mozilla.org/en-US/docs/Web/API/DecompressionStream/DecompressionStream

** possible solution: **
Can we change this line of the code

cap/widget/src/src/cap.js

Line 58 in b414eca

var ds = new DecompressionStream("deflate-raw");

and use gzip or just deflate format instead of deflate-raw?

[Colonizator1]

Well, as i see it's not just the format of some compression, it's also the format of the data itself. So if the worker sends raw data, we can't just change the decompressor to gzip... Need to write an alternate decompressor on raw js for old browsers. I generated some with Claude, and tested with old Opera browser, but i doubt it's worth to open pull-request with it.
@tiagozip, thanks for any thoughts or comments.

[tiagozip]

do the instrumentation checks themselves pass? e.g. if you manually decode the js and run it, does it pass?

[Colonizator1]

Well, I haven't tried to decode JS and run it manually. Let me describe what i found step by step. Implemented cap js in the programmatic mode, then some users complained about an error (i'm showing a specific error: if no token was calculated/obtained for verification on the backend). Then started to debug and found the console.log error in the Opera browser (ver 82):

[cap] Failed to construct 'DecompressionStream': Unsupported compression format: 'deflate-raw'

So I found that cap.min.js uses it and that the deflate-raw format is not compatible according to the specification.

Then, I just set cap.min.js locally, changed format to gzip and it failed with console log:

[cap] The compressed data was not valid: incorrect header check.

Then, i read the source code and found that the worker sends the data compressed with deflateRawSync()

Then --> the prompt with all relevant data i found --> Claude wrote some raw decompressor:

    // Pure-JS raw DEFLATE (RFC 1951) decompressor — fallback for browsers without DecompressionStream
    // (Firefox < 113, Safari < 16.4, and other older browsers)
    function _inflateRaw(data) {
        // 100 lines of magic-code 
    }
//....
    const scriptText = await new Promise((resolve, reject) => {
      // Fallback for: (1) no DecompressionStream at all (Firefox <113, Safari <16.4),
      // or (2) DecompressionStream exists but "deflate-raw" isn't supported (Chrome 80-102).
      let ds;
      if (typeof DecompressionStream !== "undefined") {
        try { ds = new DecompressionStream("deflate-raw"); } catch (_) {}
      }
      if (!ds) {
        try {
          resolve(new TextDecoder().decode(_inflateRaw(compressed)));
        } catch (e) {
          reject(e);
        }
        return;
      }

And yes, it works, my old Opera passes the challenge and token verification now. Wanna see that ai-generated decompressor?

The code of function _inflateRaw(data):

// Pure-JS raw DEFLATE (RFC 1951) decompressor — fallback for browsers without DecompressionStream
// (Firefox < 113, Safari < 16.4, and other older browsers)
function _inflateRaw(data) {
  let pos = 0;
  const out = [];

  function bits(n) {
    let v = 0;
    for (let i = 0; i < n; i++) {
      v |= ((data[pos >> 3] >> (pos & 7)) & 1) << i;
      pos++;
    }
    return v;
  }

  function buildTree(lens) {
    let ml = 0;
    for (let i = 0; i < lens.length; i++) if (lens[i] > ml) ml = lens[i];
    if (!ml) return {};
    const cnt = new Array(ml + 1).fill(0);
    for (let i = 0; i < lens.length; i++) if (lens[i]) cnt[lens[i]]++;
    const nc = new Array(ml + 1).fill(0);
    let code = 0;
    for (let i = 1; i <= ml; i++) { code = (code + cnt[i - 1]) << 1; nc[i] = code; }
    const root = {};
    for (let i = 0; i < lens.length; i++) {
      const l = lens[i];
      if (!l) continue;
      const c = nc[l]++;
      let node = root;
      for (let k = l - 1; k >= 0; k--) {
        const bit = (c >> k) & 1;
        if (!node[bit]) node[bit] = {};
        node = node[bit];
      }
      node.v = i;
    }
    return root;
  }

  function readSym(tree) {
    let node = tree;
    while (node.v === undefined) node = node[bits(1)];
    return node.v;
  }

  const LE = [0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0];
  const LB = [3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258];
  const DE = [0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13];
  const DB = [1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577];

  for (;;) {
    const bfinal = bits(1);
    const btype = bits(2);
    if (btype === 0) {
      pos = (pos + 7) & ~7;
      const bp = pos >> 3;
      const len = data[bp] | (data[bp + 1] << 8);
      pos += 32;
      for (let i = 0; i < len; i++) out.push(data[(pos >> 3) + i]);
      pos += len * 8;
    } else {
      let litTree, distTree;
      if (btype === 1) {
        const ll = new Array(288);
        for (let i = 0; i < 144; i++) ll[i] = 8;
        for (let i = 144; i < 256; i++) ll[i] = 9;
        for (let i = 256; i < 280; i++) ll[i] = 7;
        for (let i = 280; i < 288; i++) ll[i] = 8;
        litTree = buildTree(ll);
        distTree = buildTree(new Array(32).fill(5));
      } else {
        const hlit = bits(5) + 257, hdist = bits(5) + 1, hclen = bits(4) + 4;
        const clOrder = [16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15];
        const clLens = new Array(19).fill(0);
        for (let i = 0; i < hclen; i++) clLens[clOrder[i]] = bits(3);
        const clTree = buildTree(clLens);
        const allLens = new Array(hlit + hdist).fill(0);
        let i = 0;
        while (i < allLens.length) {
          const sym = readSym(clTree);
          if (sym < 16) { allLens[i++] = sym; }
          else if (sym === 16) { const prev = allLens[i - 1]; let rep = bits(2) + 3; while (rep--) allLens[i++] = prev; }
          else if (sym === 17) { i += bits(3) + 3; }
          else { i += bits(7) + 11; }
        }
        litTree = buildTree(allLens.slice(0, hlit));
        distTree = buildTree(allLens.slice(hlit));
      }
      for (;;) {
        const sym = readSym(litTree);
        if (sym < 256) { out.push(sym); }
        else if (sym === 256) { break; }
        else {
          const len = LB[sym - 257] + bits(LE[sym - 257]);
          const distSym = readSym(distTree);
          const dist = DB[distSym] + bits(DE[distSym]);
          const start = out.length - dist;
          for (let i = 0; i < len; i++) out.push(out[start + i]);
        }
      }
    }
    if (bfinal) break;
  }
  return new Uint8Array(out);
}