@prosopo/provider 4.15.14 → 4.15.16

package/dist/cjs/api/captcha/getFrictionlessCaptchaChallenge/decisionMachine.cjs

@@ -1,305 +1,242 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const common = require("@prosopo/common");
-const types = require("@prosopo/types");
-const util = require("@prosopo/util");
-const frictionlessTasks = require("../../../tasks/frictionless/frictionlessTasks.cjs");
-const frictionlessTasksUtils = require("../../../tasks/frictionless/frictionlessTasksUtils.cjs");
-const hashUserAgent = require("../../../utils/hashUserAgent.cjs");
-const metrics = require("../../metrics.cjs");
-const contextAwareValidation = require("../contextAwareValidation.cjs");
-const constants = require("./constants.cjs");
-const honeypotResponse = require("./honeypotResponse.cjs");
-const runDecisionMachine = async (input, handle) => {
-  const {
-    tasks,
-    env,
-    clientRecord,
-    dapp,
-    userSitekeyIpHash,
-    flatHeaders,
-    ipInfo
-  } = input;
-  const { req, res } = handle;
-  let { botScore, scoreComponents } = input;
-  const userAgentMismatchResponse = await runUserAgentMismatchCheck(
-    input,
-    handle
-  );
-  if (userAgentMismatchResponse) return userAgentMismatchResponse;
-  const contextResponse = await runContextAwareValidation(input, handle);
-  if (contextResponse) return contextResponse;
-  const webViewTripped = clientRecord.settings.disallowWebView === true && input.webView === true;
-  if (webViewTripped) {
-    tasks.logger.info(() => ({ msg: "WebView detected" }));
-    const scoreUpdate = tasks.frictionlessManager.scoreIncreaseWebView(
-      input.baseBotScore,
-      botScore,
-      scoreComponents
-    );
-    botScore = scoreUpdate.score;
-    scoreComponents = scoreUpdate.scoreComponents;
-    tasks.frictionlessManager.updateScore(botScore, scoreComponents);
-  }
-  const timestampTripped = frictionlessTasks.FrictionlessManager.timestampTooOld(input.timestamp);
-  if (timestampTripped) {
-    const scoreUpdate = tasks.frictionlessManager.scoreIncreaseTimestamp(
-      input.timestamp,
-      input.baseBotScore,
-      botScore,
-      scoreComponents
-    );
-    botScore = scoreUpdate.score;
-    scoreComponents = scoreUpdate.scoreComponents;
-    tasks.frictionlessManager.updateScore(botScore, scoreComponents);
-  }
-  const autoBanThreshold = clientRecord.settings.autoBanScoreThreshold;
-  if (autoBanThreshold !== void 0 && Number(botScore) >= autoBanThreshold) {
-    req.logger.info(() => ({
-      msg: "Frictionless decision",
-      data: {
-        decision: "auto_ban_score",
-        botScore,
-        autoBanThreshold,
-        token: input.token
-      }
-    }));
-    metrics.recordFrictionlessDecision("auto_ban_score");
-    await tasks.frictionlessManager.registerBlockedSession({
-      solvedImagesCount: clientRecord.settings.imageMaxRounds,
-      userSitekeyIpHash,
-      reason: types.FrictionlessReason.AUTO_BAN_SCORE,
-      siteKey: dapp,
-      ipInfo,
-      headers: flatHeaders
-    });
-    return res.status(401).json({ error: "Unauthorized" });
-  }
-  if (webViewTripped) {
-    req.logger.info(() => ({
-      msg: "Frictionless decision",
-      data: {
-        decision: "webview_detected",
-        captchaType: types.CaptchaType.image
-      }
-    }));
-    metrics.recordFrictionlessDecision("webview_detected");
-    honeypotResponse.attachHoneypot(res, clientRecord);
-    return res.json(
-      await tasks.frictionlessManager.sendImageCaptcha({
-        solvedImagesCount: Math.min(
-          env.config.captchas.solved.count * 2,
-          clientRecord.settings.imageMaxRounds
-        ),
-        userSitekeyIpHash,
-        reason: types.FrictionlessReason.WEBVIEW_DETECTED,
-        siteKey: dapp,
-        ipInfo,
-        headers: flatHeaders
-      })
-    );
-  }
-  if (timestampTripped) {
-    req.logger.info(() => ({
-      msg: "Frictionless decision",
-      data: {
-        decision: "timestamp_too_old",
-        captchaType: types.CaptchaType.image
-      }
-    }));
-    metrics.recordFrictionlessDecision("timestamp_too_old");
-    honeypotResponse.attachHoneypot(res, clientRecord);
-    return res.json(
-      await tasks.frictionlessManager.sendImageCaptcha({
-        solvedImagesCount: frictionlessTasksUtils.timestampDecayFunction(
-          input.timestamp,
-          input.decryptionFailed,
-          clientRecord.settings.imageMaxRounds
-        ),
-        userSitekeyIpHash,
-        reason: types.FrictionlessReason.OLD_TIMESTAMP,
-        siteKey: dapp,
-        ipInfo,
-        headers: flatHeaders
-      })
-    );
-  }
-  if (Number(botScore) > input.botThreshold) {
-    req.logger.info(() => ({
-      msg: "Bot score is greater than threshold",
-      data: {
-        botScore,
-        botThreshold: input.botThreshold,
-        token: input.token
-      }
-    }));
-    req.logger.info(() => ({
-      msg: "Frictionless decision",
-      data: {
-        decision: "bot_score_above_threshold",
-        captchaType: types.CaptchaType.image
-      }
-    }));
-    metrics.recordFrictionlessDecision("bot_score_above_threshold");
-    honeypotResponse.attachHoneypot(res, clientRecord);
-    return res.json(
-      await tasks.frictionlessManager.sendImageCaptcha({
-        solvedImagesCount: Math.min(
-          env.config.captchas.solved.count,
-          clientRecord.settings.imageMaxRounds
-        ),
-        userSitekeyIpHash,
-        reason: types.FrictionlessReason.BOT_SCORE_ABOVE_THRESHOLD,
-        siteKey: dapp,
-        ipInfo,
-        headers: flatHeaders
-      })
-    );
-  }
-  if (!input.currentUrl) {
-    req.logger.info(() => ({
-      msg: "Frictionless decision",
-      data: {
-        decision: "missing_current_url",
-        captchaType: types.CaptchaType.image,
-        token: input.token
-      }
-    }));
-    metrics.recordFrictionlessDecision("missing_current_url");
-    honeypotResponse.attachHoneypot(res, clientRecord);
-    return res.json(
-      await tasks.frictionlessManager.sendImageCaptcha({
-        solvedImagesCount: Math.min(
-          env.config.captchas.solved.count,
-          clientRecord.settings.imageMaxRounds
-        ),
-        userSitekeyIpHash,
-        reason: types.FrictionlessReason.MISSING_CURRENT_URL,
-        siteKey: dapp,
-        ipInfo,
-        headers: flatHeaders
-      })
-    );
-  }
-  req.logger.info(() => ({
-    msg: "Frictionless decision",
-    data: {
-      decision: "default_pow",
-      captchaType: types.CaptchaType.pow
-    }
-  }));
-  metrics.recordFrictionlessDecision("default_pow");
-  honeypotResponse.attachHoneypot(res, clientRecord);
-  return res.json(
-    await tasks.frictionlessManager.sendPowCaptcha({
-      userSitekeyIpHash,
-      siteKey: dapp,
-      ipInfo,
-      headers: flatHeaders
-    })
-  );
+const require_metrics = require("../../metrics.cjs");
+const require_frictionlessTasks = require("../../../tasks/frictionless/frictionlessTasks.cjs");
+const require_frictionlessTasksUtils = require("../../../tasks/frictionless/frictionlessTasksUtils.cjs");
+const require_hashUserAgent = require("../../../utils/hashUserAgent.cjs");
+const require_honeypotResponse = require("./honeypotResponse.cjs");
+const require_constants = require("./constants.cjs");
+const require_contextAwareValidation = require("../contextAwareValidation.cjs");
+let _prosopo_common = require("@prosopo/common");
+let _prosopo_types = require("@prosopo/types");
+let _prosopo_util = require("@prosopo/util");
+//#region src/api/captcha/getFrictionlessCaptchaChallenge/decisionMachine.ts
+var runDecisionMachine = async (input, handle) => {
+	const { tasks, env, clientRecord, dapp, userSitekeyIpHash, flatHeaders, ipInfo } = input;
+	const { req, res } = handle;
+	let { botScore, scoreComponents } = input;
+	const userAgentMismatchResponse = await runUserAgentMismatchCheck(input, handle);
+	if (userAgentMismatchResponse) return userAgentMismatchResponse;
+	const contextResponse = await runContextAwareValidation(input, handle);
+	if (contextResponse) return contextResponse;
+	const webViewTripped = clientRecord.settings.disallowWebView === true && input.webView === true;
+	if (webViewTripped) {
+		tasks.logger.info(() => ({ msg: "WebView detected" }));
+		const scoreUpdate = tasks.frictionlessManager.scoreIncreaseWebView(input.baseBotScore, botScore, scoreComponents);
+		botScore = scoreUpdate.score;
+		scoreComponents = scoreUpdate.scoreComponents;
+		tasks.frictionlessManager.updateScore(botScore, scoreComponents);
+	}
+	const timestampTripped = require_frictionlessTasks.FrictionlessManager.timestampTooOld(input.timestamp);
+	if (timestampTripped) {
+		const scoreUpdate = tasks.frictionlessManager.scoreIncreaseTimestamp(input.timestamp, input.baseBotScore, botScore, scoreComponents);
+		botScore = scoreUpdate.score;
+		scoreComponents = scoreUpdate.scoreComponents;
+		tasks.frictionlessManager.updateScore(botScore, scoreComponents);
+	}
+	const autoBanThreshold = clientRecord.settings.autoBanScoreThreshold;
+	if (autoBanThreshold !== void 0 && Number(botScore) >= autoBanThreshold) {
+		req.logger.info(() => ({
+			msg: "Frictionless decision",
+			data: {
+				decision: "auto_ban_score",
+				botScore,
+				autoBanThreshold,
+				token: input.token
+			}
+		}));
+		require_metrics.recordFrictionlessDecision("auto_ban_score");
+		await tasks.frictionlessManager.registerBlockedSession({
+			solvedImagesCount: clientRecord.settings.imageMaxRounds,
+			userSitekeyIpHash,
+			reason: _prosopo_types.FrictionlessReason.AUTO_BAN_SCORE,
+			siteKey: dapp,
+			ipInfo,
+			headers: flatHeaders
+		});
+		return res.status(401).json({ error: "Unauthorized" });
+	}
+	if (webViewTripped) {
+		req.logger.info(() => ({
+			msg: "Frictionless decision",
+			data: {
+				decision: "webview_detected",
+				captchaType: _prosopo_types.CaptchaType.image
+			}
+		}));
+		require_metrics.recordFrictionlessDecision("webview_detected");
+		require_honeypotResponse.attachHoneypot(res, clientRecord);
+		return res.json(await tasks.frictionlessManager.sendImageCaptcha({
+			solvedImagesCount: Math.min(env.config.captchas.solved.count * 2, clientRecord.settings.imageMaxRounds),
+			userSitekeyIpHash,
+			reason: _prosopo_types.FrictionlessReason.WEBVIEW_DETECTED,
+			siteKey: dapp,
+			ipInfo,
+			headers: flatHeaders
+		}));
+	}
+	if (timestampTripped) {
+		req.logger.info(() => ({
+			msg: "Frictionless decision",
+			data: {
+				decision: "timestamp_too_old",
+				captchaType: _prosopo_types.CaptchaType.image
+			}
+		}));
+		require_metrics.recordFrictionlessDecision("timestamp_too_old");
+		require_honeypotResponse.attachHoneypot(res, clientRecord);
+		return res.json(await tasks.frictionlessManager.sendImageCaptcha({
+			solvedImagesCount: require_frictionlessTasksUtils.timestampDecayFunction(input.timestamp, input.decryptionFailed, clientRecord.settings.imageMaxRounds),
+			userSitekeyIpHash,
+			reason: _prosopo_types.FrictionlessReason.OLD_TIMESTAMP,
+			siteKey: dapp,
+			ipInfo,
+			headers: flatHeaders
+		}));
+	}
+	if (Number(botScore) > input.botThreshold) {
+		req.logger.info(() => ({
+			msg: "Bot score is greater than threshold",
+			data: {
+				botScore,
+				botThreshold: input.botThreshold,
+				token: input.token
+			}
+		}));
+		req.logger.info(() => ({
+			msg: "Frictionless decision",
+			data: {
+				decision: "bot_score_above_threshold",
+				captchaType: _prosopo_types.CaptchaType.image
+			}
+		}));
+		require_metrics.recordFrictionlessDecision("bot_score_above_threshold");
+		require_honeypotResponse.attachHoneypot(res, clientRecord);
+		return res.json(await tasks.frictionlessManager.sendImageCaptcha({
+			solvedImagesCount: Math.min(env.config.captchas.solved.count, clientRecord.settings.imageMaxRounds),
+			userSitekeyIpHash,
+			reason: _prosopo_types.FrictionlessReason.BOT_SCORE_ABOVE_THRESHOLD,
+			siteKey: dapp,
+			ipInfo,
+			headers: flatHeaders
+		}));
+	}
+	if (!input.currentUrl) {
+		req.logger.info(() => ({
+			msg: "Frictionless decision",
+			data: {
+				decision: "missing_current_url",
+				captchaType: _prosopo_types.CaptchaType.image,
+				token: input.token
+			}
+		}));
+		require_metrics.recordFrictionlessDecision("missing_current_url");
+		require_honeypotResponse.attachHoneypot(res, clientRecord);
+		return res.json(await tasks.frictionlessManager.sendImageCaptcha({
+			solvedImagesCount: Math.min(env.config.captchas.solved.count, clientRecord.settings.imageMaxRounds),
+			userSitekeyIpHash,
+			reason: _prosopo_types.FrictionlessReason.MISSING_CURRENT_URL,
+			siteKey: dapp,
+			ipInfo,
+			headers: flatHeaders
+		}));
+	}
+	req.logger.info(() => ({
+		msg: "Frictionless decision",
+		data: {
+			decision: "default_pow",
+			captchaType: _prosopo_types.CaptchaType.pow
+		}
+	}));
+	require_metrics.recordFrictionlessDecision("default_pow");
+	require_honeypotResponse.attachHoneypot(res, clientRecord);
+	return res.json(await tasks.frictionlessManager.sendPowCaptcha({
+		userSitekeyIpHash,
+		siteKey: dapp,
+		ipInfo,
+		headers: flatHeaders
+	}));
 };
-const runUserAgentMismatchCheck = async (input, handle) => {
-  const { req, res } = handle;
-  const headersUserAgent = req.headers["user-agent"];
-  const headersProsopoUser = req.headers["prosopo-user"];
-  const hashedHeadersUserAgent = headersUserAgent ? hashUserAgent.hashUserAgent(headersUserAgent) : "";
-  if (hashedHeadersUserAgent === input.userAgent && headersProsopoUser === input.userId) {
-    return null;
-  }
-  req.logger.info(() => ({
-    msg: "User agent or user id does not match",
-    data: {
-      headersUserAgent,
-      hashedHeadersUserAgent,
-      userAgent: input.userAgent,
-      headersProsopoUser,
-      userId: input.userId
-    }
-  }));
-  req.logger.info(() => ({
-    msg: "Frictionless decision",
-    data: {
-      decision: "user_agent_mismatch",
-      captchaType: types.CaptchaType.image
-    }
-  }));
-  metrics.recordFrictionlessDecision("user_agent_mismatch");
-  honeypotResponse.attachHoneypot(res, input.clientRecord);
-  return res.json(
-    await input.tasks.frictionlessManager.sendImageCaptcha({
-      solvedImagesCount: frictionlessTasksUtils.timestampDecayFunction(
-        input.timestamp,
-        input.decryptionFailed,
-        input.clientRecord.settings.imageMaxRounds
-      ),
-      userSitekeyIpHash: input.userSitekeyIpHash,
-      reason: types.FrictionlessReason.USER_AGENT_MISMATCH,
-      siteKey: input.dapp,
-      ipInfo: input.ipInfo,
-      headers: input.flatHeaders
-    })
-  );
+var runUserAgentMismatchCheck = async (input, handle) => {
+	const { req, res } = handle;
+	const headersUserAgent = req.headers["user-agent"];
+	const headersProsopoUser = req.headers["prosopo-user"];
+	const hashedHeadersUserAgent = headersUserAgent ? require_hashUserAgent.hashUserAgent(headersUserAgent) : "";
+	if (hashedHeadersUserAgent === input.userAgent && headersProsopoUser === input.userId) return null;
+	req.logger.info(() => ({
+		msg: "User agent or user id does not match",
+		data: {
+			headersUserAgent,
+			hashedHeadersUserAgent,
+			userAgent: input.userAgent,
+			headersProsopoUser,
+			userId: input.userId
+		}
+	}));
+	req.logger.info(() => ({
+		msg: "Frictionless decision",
+		data: {
+			decision: "user_agent_mismatch",
+			captchaType: _prosopo_types.CaptchaType.image
+		}
+	}));
+	require_metrics.recordFrictionlessDecision("user_agent_mismatch");
+	require_honeypotResponse.attachHoneypot(res, input.clientRecord);
+	return res.json(await input.tasks.frictionlessManager.sendImageCaptcha({
+		solvedImagesCount: require_frictionlessTasksUtils.timestampDecayFunction(input.timestamp, input.decryptionFailed, input.clientRecord.settings.imageMaxRounds),
+		userSitekeyIpHash: input.userSitekeyIpHash,
+		reason: _prosopo_types.FrictionlessReason.USER_AGENT_MISMATCH,
+		siteKey: input.dapp,
+		ipInfo: input.ipInfo,
+		headers: input.flatHeaders
+	}));
 };
-const runContextAwareValidation = async (input, handle) => {
-  const { tasks, clientRecord, dapp, user } = input;
-  const { req, res, next } = handle;
-  if (!clientRecord.settings.contextAware?.enabled) return null;
-  const contexts = clientRecord.settings.contextAware?.contexts || {};
-  const hasDefault = contexts[types.ContextType.Default] !== void 0;
-  const hasWebview = contexts[types.ContextType.Webview] !== void 0;
-  let contextType;
-  if (hasDefault && hasWebview) {
-    contextType = contextAwareValidation.determineContextType(input.webView);
-  } else if (hasDefault) {
-    contextType = types.ContextType.Default;
-  } else if (hasWebview) {
-    contextType = types.ContextType.Webview;
-  }
-  if (!contextType) return null;
-  const clientEntropy = await tasks.frictionlessManager.getClientContextEntropy(
-    clientRecord.account,
-    contextType
-  );
-  if (!clientEntropy) return null;
-  if (!input.decryptedHeadHash) {
-    tasks.logger.info(() => ({
-      msg: "No decryptedHeadHash in session for context aware client"
-    }));
-    return next(
-      new common.ProsopoApiError("API.BAD_REQUEST", {
-        context: { code: 400, siteKey: dapp, user },
-        i18n: req.i18n,
-        logger: req.logger
-      })
-    );
-  }
-  const threshold = contextAwareValidation.getContextThreshold(clientRecord.settings, contextType);
-  const sim = util.compareBinaryStrings(input.decryptedHeadHash, clientEntropy);
-  if (sim >= threshold) return null;
-  req.logger.info(() => ({
-    msg: "Frictionless decision",
-    data: {
-      decision: "context_aware_failed",
-      captchaType: types.CaptchaType.image,
-      sim,
-      threshold
-    }
-  }));
-  metrics.recordFrictionlessDecision("context_aware_failed");
-  honeypotResponse.attachHoneypot(res, clientRecord);
-  return res.json(
-    await tasks.frictionlessManager.sendImageCaptcha({
-      solvedImagesCount: Math.min(
-        constants.getRoundsFromSimScore(sim),
-        clientRecord.settings.imageMaxRounds
-      ),
-      userSitekeyIpHash: input.userSitekeyIpHash,
-      reason: types.FrictionlessReason.CONTEXT_AWARE_VALIDATION_FAILED,
-      siteKey: dapp,
-      ipInfo: input.ipInfo,
-      headers: input.flatHeaders
-    })
-  );
+var runContextAwareValidation = async (input, handle) => {
+	const { tasks, clientRecord, dapp, user } = input;
+	const { req, res, next } = handle;
+	if (!clientRecord.settings.contextAware?.enabled) return null;
+	const contexts = clientRecord.settings.contextAware?.contexts || {};
+	const hasDefault = contexts[_prosopo_types.ContextType.Default] !== void 0;
+	const hasWebview = contexts[_prosopo_types.ContextType.Webview] !== void 0;
+	let contextType;
+	if (hasDefault && hasWebview) contextType = require_contextAwareValidation.determineContextType(input.webView);
+	else if (hasDefault) contextType = _prosopo_types.ContextType.Default;
+	else if (hasWebview) contextType = _prosopo_types.ContextType.Webview;
+	if (!contextType) return null;
+	const clientEntropy = await tasks.frictionlessManager.getClientContextEntropy(clientRecord.account, contextType);
+	if (!clientEntropy) return null;
+	if (!input.decryptedHeadHash) {
+		tasks.logger.info(() => ({ msg: "No decryptedHeadHash in session for context aware client" }));
+		return next(new _prosopo_common.ProsopoApiError("API.BAD_REQUEST", {
+			context: {
+				code: 400,
+				siteKey: dapp,
+				user
+			},
+			i18n: req.i18n,
+			logger: req.logger
+		}));
+	}
+	const threshold = require_contextAwareValidation.getContextThreshold(clientRecord.settings, contextType);
+	const sim = (0, _prosopo_util.compareBinaryStrings)(input.decryptedHeadHash, clientEntropy);
+	if (sim >= threshold) return null;
+	req.logger.info(() => ({
+		msg: "Frictionless decision",
+		data: {
+			decision: "context_aware_failed",
+			captchaType: _prosopo_types.CaptchaType.image,
+			sim,
+			threshold
+		}
+	}));
+	require_metrics.recordFrictionlessDecision("context_aware_failed");
+	require_honeypotResponse.attachHoneypot(res, clientRecord);
+	return res.json(await tasks.frictionlessManager.sendImageCaptcha({
+		solvedImagesCount: Math.min(require_constants.getRoundsFromSimScore(sim), clientRecord.settings.imageMaxRounds),
+		userSitekeyIpHash: input.userSitekeyIpHash,
+		reason: _prosopo_types.FrictionlessReason.CONTEXT_AWARE_VALIDATION_FAILED,
+		siteKey: dapp,
+		ipInfo: input.ipInfo,
+		headers: input.flatHeaders
+	}));
 };
+//#endregion
 exports.runDecisionMachine = runDecisionMachine;

package/dist/cjs/api/captcha/getFrictionlessCaptchaChallenge/decryptSimdReadings.cjs

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const decryptIncomingSimdReadings = async (manager, encrypted) => {
-  if (!encrypted) return void 0;
-  const decryptKeys = [
-    ...await manager.getDetectorKeys(),
-    process.env.BOT_DECRYPTION_KEY
-  ];
-  const decrypted = await manager.decryptSimdReadings(encrypted, decryptKeys);
-  if (!decrypted) return void 0;
-  const { timestamp: _ignored, ...readings } = decrypted;
-  return readings;
+//#region src/api/captcha/getFrictionlessCaptchaChallenge/decryptSimdReadings.ts
+var decryptIncomingSimdReadings = async (manager, encrypted) => {
+	if (!encrypted) return void 0;
+	const decryptKeys = [...await manager.getDetectorKeys(), process.env.BOT_DECRYPTION_KEY];
+	const decrypted = await manager.decryptSimdReadings(encrypted, decryptKeys);
+	if (!decrypted) return void 0;
+	const { timestamp: _ignored, ...readings } = decrypted;
+	return readings;
 };
+//#endregion
 exports.decryptIncomingSimdReadings = decryptIncomingSimdReadings;