packages/shared/lib/api/helpers/deviceVerificationHandler.ts

   1 import { create as createMutex } from '@protontech/mutex-browser';
   2
   3 import { createOnceHandler } from '@proton/shared/lib/apiHandlers';
   4 import { wait } from '@proton/shared/lib/helpers/promise';
   5 import pbkdfWorkerWrapper from '@proton/shared/lib/pow/pbkdfWorkerWrapper';
   6 import noop from '@proton/utils/noop';
   7 import randomIntFromInterval from '@proton/utils/randomIntFromInterval';
   8
   9 import localStorageWithExpiry from './localStorageWithExpiry';
  10
  11 const onSolve = (b64Source: string): Promise<string> => {
  12     return new Promise((resolve, reject) => {
  13         try {
  14             const pbkdfWorker = pbkdfWorkerWrapper();
  15             pbkdfWorker.postMessage({ b64Source });
  16
  17             pbkdfWorker.onmessage = (event) => {
  18                 resolve(event.data);
  19             };
  20
  21             pbkdfWorker.onerror = (error) => {
  22                 reject(error);
  23             };
  24         } catch (error) {
  25             reject(error);
  26         }
  27     });
  28 };
  29
  30 export const createDeviceHandlers = () => {
  31     const deviceVerificationHandlers: { [key: string]: ReturnType<typeof createOnceHandler<string, string>> } = {};
  32
  33     const deviceVerificationHandler = (
  34         UID: string,
  35         challengeType: number,
  36         challengePayload: string
  37     ): Promise<string> => {
  38         if (!deviceVerificationHandlers[UID]) {
  39             const mutex = createMutex({ expiry: 15000 });
  40
  41             const getMutexLock = async (UID: string) => {
  42                 try {
  43                     await mutex.lock(UID);
  44                     return () => {
  45                         return mutex.unlock(UID).catch(noop);
  46                     };
  47                 } catch (e) {
  48                     // If getting the mutex fails, fall back to a random wait
  49                     await wait(randomIntFromInterval(100, 2000));
  50                     return () => {
  51                         return Promise.resolve();
  52                     };
  53                 }
  54             };
  55
  56             deviceVerificationHandlers[UID] = createOnceHandler(async (challengePayload: string): Promise<string> => {
  57                 const unlockMutex = await getMutexLock(UID);
  58                 let token = '';
  59                 try {
  60                     const lastCachedDate = localStorageWithExpiry.getData(challengePayload);
  61                     if (!lastCachedDate) {
  62                         token = await onSolve(challengePayload);
  63                         localStorageWithExpiry.storeData(challengePayload, token, 1 * 60 * 1000);
  64                         await wait(50);
  65                     } else {
  66                         token = lastCachedDate;
  67                     }
  68                 } catch (e) {
  69                     throw e;
  70                 } finally {
  71                     await unlockMutex();
  72                 }
  73                 return token;
  74             });
  75         }
  76
  77         return deviceVerificationHandlers[UID](challengePayload);
  78     };
  79
  80     return deviceVerificationHandler;
  81 };