rentgen/stolen-data-entry.ts

221 lines
5.5 KiB
TypeScript
Raw Normal View History

2021-11-22 17:54:15 +01:00
// import { TCModel } from "@iabtcf/core";
2021-11-21 23:00:55 +01:00
import { EventEmitter } from "events";
2021-11-08 20:14:28 +01:00
import ExtendedRequest, { HAREntry } from "./extended-request";
2021-11-07 17:44:22 +01:00
import {
2021-11-07 19:15:40 +01:00
getshorthost,
isBase64,
isBase64JSON,
2021-11-07 17:44:22 +01:00
isJSONObject,
isURL,
2021-11-22 18:56:36 +01:00
maskString,
2021-11-07 17:44:22 +01:00
parseToObject,
} from "./util";
export type Sources = "cookie" | "pathname" | "queryparams" | "header";
2021-11-07 17:44:22 +01:00
export const Classifications = <const>{
id: "Sztucznie nadane ID",
history: "Część historii przeglądania",
location: "Informacje na temat mojego położenia",
2021-11-07 17:44:22 +01:00
};
const ID_PREVIEW_MAX_LENGTH = 20;
const id = (function* id() {
let i = 0;
while (true) {
i++;
yield i;
}
})();
export type DecodingSchema = "base64" | "raw";
2021-11-21 23:00:55 +01:00
export class StolenDataEntry extends EventEmitter {
public isIAB = false;
2021-11-22 17:54:15 +01:00
// public iab: TCModel | null = null;
public id: number;
2021-11-22 17:54:15 +01:00
private marked = false;
2021-11-07 17:44:22 +01:00
public classification: keyof typeof Classifications;
public decoding_applied: DecodingSchema = "raw";
public decodings_available: DecodingSchema[] = ["raw"];
constructor(
public request: ExtendedRequest,
public source: Sources,
public name: string,
public value: string
) {
// try {
// this.iab = TCString.decode(value);
// // console.log(this.iab);
// this.isIAB = true;
// } catch (e) {}
2021-11-21 23:00:55 +01:00
super();
this.id = id.next().value as number;
2021-11-07 17:44:22 +01:00
this.classification = this.classify();
if (isBase64(value)) {
this.decodings_available.push("base64");
}
}
getPriority() {
let priority = 0;
priority += Math.min(this.value.length, 50);
const url = new URL(this.request.originalURL);
if (this.value.includes(url.host)) {
priority += 100;
}
if (this.value.includes(url.pathname)) {
priority += 100;
}
if (this.source === "cookie") {
priority += 200;
}
return priority;
}
2021-11-22 17:54:15 +01:00
get isMarked() {
return this.marked;
}
hasValue(value: string) {
return this.value === value;
}
static parseValue(value: unknown): string | Record<string, unknown> {
2021-11-22 17:54:15 +01:00
if (isBase64JSON(value)) {
return StolenDataEntry.parseValue({ base64: JSON.parse(atob(value)) });
}
if (value === undefined) {
return "";
}
if (isJSONObject(value)) {
const object = parseToObject(value);
return object;
} else if (isURL(value)) {
const url = new URL(value);
let hash = url.hash;
if (hash.includes("=")) {
//facebook sometimes includes querystring-encoded data into the hash... attempt to parse it
try {
hash = Object.fromEntries(
hash
.slice(1)
.split("&")
.map((kv) => kv.split("="))
);
} catch (e) {
// failed to parse as query string
console.log(
"Failed attempt to parse hash location as query string, probably safe to ignore:",
e
);
}
}
const searchParams = Object.fromEntries(
((url.searchParams as unknown) as {
entries: () => Iterable<[string, string]>;
}).entries()
);
if (typeof hash !== "object" && Object.keys(searchParams).length === 0) {
return value; // just a string;
}
const object = {
[Symbol.for("originalString")]: value, // so it doesn't appear raw in the table but can be easily retrieved later
host: url.host,
path: url.pathname,
searchParams,
...(hash === "" ? {} : typeof hash === "string" ? { hash } : hash),
};
return object;
} else if (value === null) {
return "null";
} else {
return value.toString();
}
}
getParsedValue(key_path: string): string | Record<string | symbol, unknown> {
let object = StolenDataEntry.parseValue(this.value);
for (const key of key_path.split(".")) {
if (key === "") continue;
object = StolenDataEntry.parseValue(object[key]);
}
return object;
}
2021-11-22 17:54:15 +01:00
mark() {
this.marked = true;
2021-11-21 23:00:55 +01:00
this.emit("change");
}
2021-11-22 17:54:15 +01:00
unmark() {
this.marked = false;
2021-11-21 23:00:55 +01:00
this.emit("change");
}
2021-11-22 17:54:15 +01:00
toggleMark() {
if (this.marked) {
this.unmark();
} else {
2021-11-22 17:54:15 +01:00
this.mark();
}
}
2021-11-07 17:44:22 +01:00
private classify(): keyof typeof Classifications {
2021-11-07 19:15:40 +01:00
let result: keyof typeof Classifications;
if (
[this.value, decodeURIComponent(this.value)].some((haystack) =>
[
this.request.origin,
this.request.originalURL,
getshorthost(this.request.origin),
].some((needle) => haystack.includes(needle))
)
) {
result = "history";
2021-11-07 17:44:22 +01:00
} else {
2021-11-07 19:15:40 +01:00
result = "id";
2021-11-07 17:44:22 +01:00
}
2021-11-07 19:15:40 +01:00
return result;
2021-11-07 17:44:22 +01:00
}
2021-11-07 17:51:30 +01:00
isRelatedToID() {
return this.request.stolenData.some(
(entry) => entry.classification == "id"
2021-11-07 17:51:30 +01:00
);
}
2021-11-08 20:14:28 +01:00
matchesHAREntry(har: HAREntry): boolean {
return this.request.matchesHAREntry(har);
}
getValuePreview(key = ""): string {
const value = this.getParsedValue(key);
const str =
typeof value === "object" && value[Symbol.for("originalString")]
? (value[Symbol.for("originalString")] as string)
: value.toString();
if (typeof value !== "object" && this.classification == "id") {
2021-11-22 18:56:36 +01:00
return maskString(value, 1 / 3, ID_PREVIEW_MAX_LENGTH);
} else if (
typeof value === "object" &&
value[Symbol.for("originalString")]
) {
return value[Symbol.for("originalString")] as string;
} else {
return str;
}
}
getUniqueKey() {
2021-11-22 17:54:15 +01:00
return this.request.shorthost + ";" + this.name + ";" + this.value;
}
exposesOrigin(): boolean {
return this.value.includes(getshorthost(this.request.origin));
}
}