@prosopo/provider 3.13.0 → 3.13.7

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

@@ -10,6 +10,7 @@ const hashUserAgent = require("../../utils/hashUserAgent.cjs");
 const hashUserIp = require("../../utils/hashUserIp.cjs");
 const apiToggleMaintenanceModeEndpoint = require("../admin/apiToggleMaintenanceModeEndpoint.cjs");
 const blacklistRequestInspector = require("../blacklistRequestInspector.cjs");
+const contextAwareValidation = require("./contextAwareValidation.cjs");
 const tasks = require("../../tasks/tasks.cjs");
 const DEFAULT_FRICTIONLESS_THRESHOLD = 0.5;
 const getRoundsFromSimScore = (simScore) => {
@@ -91,7 +92,8 @@ const getFrictionlessCaptchaChallenge = (env, userAccessRulesStorage) => async (
       userAgent,
       webView,
       iFrame,
-      decryptedHeadHash
+      decryptedHeadHash,
+      decryptionFailed
     } = await tasks$1.frictionlessManager.decryptPayload(token, headHash);
     req.logger.debug(() => ({
       msg: "Decrypted payload",
@@ -161,29 +163,6 @@ const getFrictionlessCaptchaChallenge = (env, userAccessRulesStorage) => async (
       dapp,
       userScope
     ))[0];
-    const headersUserAgent = req.headers["user-agent"];
-    const hashedHeadersUserAgent = headersUserAgent ? hashUserAgent.hashUserAgent(headersUserAgent) : "";
-    const headersProsopoUser = req.headers["prosopo-user"];
-    if (hashedHeadersUserAgent !== userAgent || headersProsopoUser !== userId) {
-      req.logger.info(() => ({
-        msg: "User agent or user id does not match",
-        data: {
-          headersUserAgent,
-          hashedHeadersUserAgent,
-          userAgent,
-          // This is the hashed user agent from the token
-          headersProsopoUser,
-          userId
-        }
-      }));
-      return res.json(
-        await tasks$1.frictionlessManager.sendImageCaptcha({
-          solvedImagesCount: frictionlessTasksUtils.timestampDecayFunction(timestamp),
-          userSitekeyIpHash,
-          reason: frictionlessTasks.FrictionlessReason.USER_AGENT_MISMATCH
-        })
-      );
-    }
     if (userAccessPolicy) {
       const scoreUpdate = tasks$1.frictionlessManager.scoreIncreaseAccessPolicy(
         userAccessPolicy,
@@ -212,37 +191,83 @@ const getFrictionlessCaptchaChallenge = (env, userAccessRulesStorage) => async (
         );
       }
     }
-    if (clientRecord.settings.contextAware?.enabled) {
-      const clientEntropy = await tasks$1.frictionlessManager.getClientEntropy(
-        clientRecord.account
-      );
-      if (clientEntropy) {
-        if (!decryptedHeadHash) {
-          tasks$1.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 headersUserAgent = req.headers["user-agent"];
+    const hashedHeadersUserAgent = headersUserAgent ? hashUserAgent.hashUserAgent(headersUserAgent) : "";
+    const headersProsopoUser = req.headers["prosopo-user"];
+    if (hashedHeadersUserAgent !== userAgent || headersProsopoUser !== userId) {
+      req.logger.info(() => ({
+        msg: "User agent or user id does not match",
+        data: {
+          headersUserAgent,
+          hashedHeadersUserAgent,
+          userAgent,
+          // This is the hashed user agent from the token
+          headersProsopoUser,
+          userId
         }
-        const sim = util.compareBinaryStrings(decryptedHeadHash, clientEntropy);
-        const isValidContext = sim >= clientRecord.settings.contextAware.threshold;
-        if (!isValidContext) {
-          return res.json(
-            await tasks$1.frictionlessManager.sendImageCaptcha({
-              solvedImagesCount: getRoundsFromSimScore(sim),
-              userSitekeyIpHash,
-              reason: frictionlessTasks.FrictionlessReason.CONTEXT_AWARE_VALIDATION_FAILED
-            })
+      }));
+      return res.json(
+        await tasks$1.frictionlessManager.sendImageCaptcha({
+          solvedImagesCount: frictionlessTasksUtils.timestampDecayFunction(
+            timestamp,
+            decryptionFailed
+          ),
+          userSitekeyIpHash,
+          reason: frictionlessTasks.FrictionlessReason.USER_AGENT_MISMATCH
+        })
+      );
+    }
+    if (clientRecord.settings.contextAware?.enabled) {
+      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(webView);
+      } else if (hasDefault) {
+        contextType = types.ContextType.Default;
+      } else if (hasWebview) {
+        contextType = types.ContextType.Webview;
+      } else {
+        contextType = void 0;
+      }
+      if (contextType) {
+        const clientEntropy = await tasks$1.frictionlessManager.getClientContextEntropy(
+          clientRecord.account,
+          contextType
+        );
+        if (clientEntropy) {
+          if (!decryptedHeadHash) {
+            tasks$1.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(decryptedHeadHash, clientEntropy);
+          const isValidContext = sim >= threshold;
+          if (!isValidContext) {
+            return res.json(
+              await tasks$1.frictionlessManager.sendImageCaptcha({
+                solvedImagesCount: getRoundsFromSimScore(sim),
+                userSitekeyIpHash,
+                reason: frictionlessTasks.FrictionlessReason.CONTEXT_AWARE_VALIDATION_FAILED
+              })
+            );
+          }
         }
       }
     }
@@ -278,7 +303,10 @@ const getFrictionlessCaptchaChallenge = (env, userAccessRulesStorage) => async (
       tasks$1.frictionlessManager.updateScore(botScore, scoreComponents);
       return res.json(
         await tasks$1.frictionlessManager.sendImageCaptcha({
-          solvedImagesCount: frictionlessTasksUtils.timestampDecayFunction(timestamp),
+          solvedImagesCount: frictionlessTasksUtils.timestampDecayFunction(
+            timestamp,
+            decryptionFailed
+          ),
           userSitekeyIpHash,
           reason: frictionlessTasks.FrictionlessReason.OLD_TIMESTAMP
         })

package/dist/cjs/tasks/client/clientTasks.cjs

@@ -6,6 +6,7 @@ const database = require("@prosopo/database");
 const types = require("@prosopo/types");
 const util = require("@prosopo/util");
 const validateAddress = require("../../api/validateAddress.cjs");
+const SAMPLE_SIZE = 100;
 const isValidPrivateKey = (privateKeyString) => {
   const privateKey = Buffer.from(privateKeyString, "base64").toString("ascii");
   try {
@@ -163,7 +164,13 @@ class ClientTaskManager {
         this.logger
       );
       const tenMinuteWindow = 10 * 60 * 1e3;
-      const updatedAtTimestamp = lastTask?.updated ? lastTask.updated.getTime() - tenMinuteWindow || 0 : 0;
+      const updatedAtTimestamp = (() => {
+        const raw = lastTask?.updated;
+        if (!raw) return 0;
+        const ts = raw instanceof Date ? raw.getTime() : Date.parse(String(raw));
+        if (Number.isNaN(ts)) return 0;
+        return Math.max(ts - tenMinuteWindow, 0);
+      })();
       this.logger.info(() => ({
         msg: `Getting updated client records since ${new Date(updatedAtTimestamp).toDateString()}`
       }));
@@ -201,14 +208,71 @@ class ClientTaskManager {
    * @returns Promise<void>
    */
   async calculateClientEntropy() {
-    const clients = await this.providerDB.getAllClientRecords();
-    for (const client of clients) {
-      const sampleEntropies = await this.providerDB.sampleEntropy(
-        100,
-        client.account
+    const taskID = await this.providerDB.createScheduledTaskStatus(
+      types.ScheduledTaskNames.SetClientEntropy,
+      types.ScheduledTaskStatus.Running
+    );
+    try {
+      let clients = await this.providerDB.getAllClientRecords();
+      clients = clients.filter((client) => client.tier !== types.Tier.Free);
+      this.logger.info(() => ({
+        msg: `Calculating entropies for ${clients.length} clients`
+      }));
+      for (const client of clients) {
+        if (client.settings?.contextAware?.enabled) {
+          const contextTypes = Object.keys(
+            client.settings.contextAware.contexts ?? {}
+          );
+          for (const contextType of contextTypes) {
+            const contextSamples = await this.providerDB.sampleContextEntropy(
+              SAMPLE_SIZE,
+              client.account,
+              contextType
+            );
+            if (contextSamples.length < SAMPLE_SIZE) {
+              this.logger.info(() => ({
+                msg: `Skipping ${contextType} entropy calculation for client ${client.account} due to insufficient samples (${contextSamples.length}/${SAMPLE_SIZE})`
+              }));
+              continue;
+            }
+            const contextAvgEntropy = util.majorityAverage(contextSamples);
+            this.logger.info(() => ({
+              msg: `Calculated ${contextType} entropy for client ${client.account}: ${contextAvgEntropy}`
+            }));
+            await this.providerDB.setClientContextEntropy(
+              client.account,
+              contextType,
+              contextAvgEntropy
+            );
+          }
+        }
+      }
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        types.ScheduledTaskStatus.Completed,
+        {
+          data: {
+            clientRecords: clients.length
+          }
+        }
+      );
+    } catch (e) {
+      const calculateClientEntropiesError = new common.ProsopoApiError(
+        "DATABASE.UNKNOWN",
+        {
+          context: { error: e },
+          logger: this.logger
+        }
+      );
+      this.logger.error(() => ({
+        err: calculateClientEntropiesError,
+        msg: "Error calculating client entropy"
+      }));
+      await this.providerDB.updateScheduledTaskStatus(
+        taskID,
+        types.ScheduledTaskStatus.Failed,
+        { error: String(e) }
       );
-      const avgEntropy = util.majorityAverage(sampleEntropies);
-      await this.providerDB.setClientEntropy(client.account, avgEntropy);
     }
   }
   async registerSiteKey(siteKey, tier, settings) {