/* This file is part of GNU Taler (C) 2022 Taler Systems S.A. GNU Taler is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Taler; see the file COPYING. If not, see */ /** * Messaging for the WebExtensions wallet. Should contain * parts that are specific for WebExtensions, but as little business * logic as possible. */ /** * Imports. */ import { classifyTalerUri, Logger, LogLevel, setGlobalLogLevelFromString, setLogLevelFromString, TalerErrorCode, TalerUriType, WalletDiagnostics, makeErrorDetail, getErrorDetailFromException, } from "@gnu-taler/taler-util"; import { DbAccess, deleteTalerDatabase, exportDb, importDb, OpenedPromise, openPromise, openTalerDatabase, SetTimeoutTimerAPI, Wallet, WalletOperations, WalletStoresV1, } from "@gnu-taler/taler-wallet-core"; import { BrowserHttpLib } from "./browserHttpLib.js"; import { platform } from "./platform/background.js"; import { MessageFromBackend, MessageFromFrontend, MessageResponse, } from "./platform/api.js"; import { SynchronousCryptoWorkerFactory } from "./serviceWorkerCryptoWorkerFactory.js"; import { ServiceWorkerHttpLib } from "./serviceWorkerHttpLib.js"; import { BackgroundOperations, ExtendedPermissionsResponse } from "./wxApi.js"; /** * Currently active wallet instance. Might be unloaded and * re-instantiated when the database is reset. * * FIXME: Maybe move the wallet resetting into the Wallet class? */ let currentWallet: Wallet | undefined; let currentDatabase: DbAccess | undefined; /** * Last version of an outdated DB, if applicable. */ let outdatedDbVersion: number | undefined; const walletInit: OpenedPromise = openPromise(); const logger = new Logger("wxBackend.ts"); async function getDiagnostics(): Promise { const manifestData = platform.getWalletWebExVersion(); const errors: string[] = []; let firefoxIdbProblem = false; let dbOutdated = false; try { await walletInit.promise; } catch (e) { errors.push("Error during wallet initialization: " + e); if ( currentDatabase === undefined && outdatedDbVersion === undefined && platform.isFirefox() ) { firefoxIdbProblem = true; } } if (!currentWallet) { errors.push("Could not create wallet backend."); } if (!currentDatabase) { errors.push("Could not open database"); } if (outdatedDbVersion !== undefined) { errors.push(`Outdated DB version: ${outdatedDbVersion}`); dbOutdated = true; } const diagnostics: WalletDiagnostics = { walletManifestDisplayVersion: manifestData.version_name || "(undefined)", walletManifestVersion: manifestData.version, errors, firefoxIdbProblem, dbOutdated, }; return diagnostics; } type BackendHandlerType = { [Op in keyof BackgroundOperations]: ( req: BackgroundOperations[Op]["request"], ) => Promise; }; async function containsHeaderListener(): Promise { const result = await platform.containsTalerHeaderListener(); return { newValue: result }; } async function resetDb(): Promise { await deleteTalerDatabase(indexedDB as any); await reinitWallet(); } async function runGarbageCollector(): Promise { const dbBeforeGc = currentDatabase; if (!dbBeforeGc) { throw Error("no current db before running gc"); } const dump = await exportDb(dbBeforeGc.idbHandle()); await deleteTalerDatabase(indexedDB as any); logger.info("cleaned"); await reinitWallet(); logger.info("init"); const dbAfterGc = currentDatabase; if (!dbAfterGc) { throw Error("no current db before running gc"); } await importDb(dbAfterGc.idbHandle(), dump); logger.info("imported"); } async function toggleHeaderListener( newVal: boolean, ): Promise { logger.trace("new extended permissions value", newVal); if (newVal) { platform.registerTalerHeaderListener(parseTalerUriAndRedirect); return { newValue: true }; } const rem = await platform.getPermissionsApi().removeHostPermissions(); logger.trace("permissions removed:", rem); return { newValue: false }; } function freeze(time: number): Promise { return new Promise((res, rej) => { setTimeout(res, time); }); } async function sum(ns: Array): Promise { return ns.reduce((prev, cur) => prev + cur, 0); } const backendHandlers: BackendHandlerType = { freeze, sum, containsHeaderListener, getDiagnostics, resetDb, runGarbageCollector, toggleHeaderListener, setLoggingLevel, }; async function setLoggingLevel({ tag, level, }: { tag?: string; level: LogLevel; }): Promise { logger.info(`setting ${tag} to ${level}`); if (!tag) { setGlobalLogLevelFromString(level); } else { setLogLevelFromString(tag, level); } } async function dispatch( req: MessageFromFrontend & { id: string }, ): Promise { if (req.channel === "background") { const handler = backendHandlers[req.operation] as (req: any) => any; if (!handler) { return { type: "error", id: req.id, operation: String(req.operation), error: getErrorDetailFromException( Error(`unknown background operation`), ), }; } try { const result = await handler(req.payload); return { type: "response", id: req.id, operation: String(req.operation), result, }; } catch (er) { return { type: "error", id: req.id, error: getErrorDetailFromException(er), operation: String(req.operation), }; } } if (req.channel === "wallet") { const w = currentWallet; if (!w) { return { type: "error", id: req.id, operation: req.operation, error: makeErrorDetail( TalerErrorCode.WALLET_CORE_NOT_AVAILABLE, {}, "wallet core not available", ), }; } return await w.handleCoreApiRequest(req.operation, req.id, req.payload); } const anyReq = req as any; return { type: "error", id: anyReq.id, operation: String(anyReq.operation), error: getErrorDetailFromException( Error( `unknown channel ${anyReq.channel}, should be "background" or "wallet"`, ), ), }; } async function reinitWallet(): Promise { if (currentWallet) { currentWallet.stop(); currentWallet = undefined; } currentDatabase = undefined; // setBadgeText({ text: "" }); try { currentDatabase = await openTalerDatabase(indexedDB as any, reinitWallet); } catch (e) { logger.error("could not open database", e); walletInit.reject(e); return; } let httpLib; let cryptoWorker; let timer; if (platform.useServiceWorkerAsBackgroundProcess()) { httpLib = new ServiceWorkerHttpLib(); cryptoWorker = new SynchronousCryptoWorkerFactory(); timer = new SetTimeoutTimerAPI(); } else { httpLib = new BrowserHttpLib(); // We could (should?) use the BrowserCryptoWorkerFactory here, // but right now we don't, to have less platform differences. // cryptoWorker = new BrowserCryptoWorkerFactory(); cryptoWorker = new SynchronousCryptoWorkerFactory(); timer = new SetTimeoutTimerAPI(); } logger.info("Setting up wallet"); const wallet = await Wallet.create( currentDatabase, httpLib, timer, cryptoWorker, ); try { await wallet.handleCoreApiRequest("initWallet", "native-init", {}); } catch (e) { logger.error("could not initialize wallet", e); walletInit.reject(e); return; } wallet.addNotificationListener((x) => { const message: MessageFromBackend = { type: x.type }; platform.sendMessageToAllChannels(message); }); platform.keepAlive(() => { return wallet.runTaskLoop().catch((e) => { logger.error("error during wallet task loop", e); }); }); // Useful for debugging in the background page. if (typeof window !== "undefined") { (window as any).talerWallet = wallet; } currentWallet = wallet; return walletInit.resolve(); } function parseTalerUriAndRedirect(tabId: number, maybeTalerUri: string): void { const talerUri = maybeTalerUri.startsWith("ext+") ? maybeTalerUri.substring(4) : maybeTalerUri; const uriType = classifyTalerUri(talerUri); switch (uriType) { case TalerUriType.TalerWithdraw: return platform.redirectTabToWalletPage( tabId, `/cta/withdraw?talerWithdrawUri=${encodeURIComponent(talerUri)}`, ); case TalerUriType.TalerPay: return platform.redirectTabToWalletPage( tabId, `/cta/pay?talerPayUri=${encodeURIComponent(talerUri)}`, ); case TalerUriType.TalerTip: return platform.redirectTabToWalletPage( tabId, `/cta/tip?talerTipUri=${encodeURIComponent(talerUri)}`, ); case TalerUriType.TalerRefund: return platform.redirectTabToWalletPage( tabId, `/cta/refund?talerRefundUri=${encodeURIComponent(talerUri)}`, ); case TalerUriType.TalerPayPull: return platform.redirectTabToWalletPage( tabId, `/cta/invoice/pay?talerPayPullUri=${encodeURIComponent(talerUri)}`, ); case TalerUriType.TalerPayPush: return platform.redirectTabToWalletPage( tabId, `/cta/transfer/pickup?talerPayPushUri=${encodeURIComponent(talerUri)}`, ); case TalerUriType.TalerRecovery: return platform.redirectTabToWalletPage( tabId, `/cta/transfer/recovery?talerBackupUri=${encodeURIComponent(talerUri)}`, ); case TalerUriType.TalerPayTemplate: return platform.redirectTabToWalletPage( tabId, `/cta/pay/template?talerPayTemplateUri=${encodeURIComponent(talerUri)}`, ); return; case TalerUriType.Unknown: logger.warn( `Response with HTTP 402 the Taler header but could not classify ${talerUri}`, ); return; case TalerUriType.TalerDevExperiment: // FIXME: Implement! logger.warn("not implemented"); return; case TalerUriType.TalerTemplate: logger.warn("not implemented"); return; default: { const error: never = uriType; logger.warn( `Response with HTTP 402 the Taler header "${error}", but header value is not a taler:// URI.`, ); return; } } } /** * Main function to run for the WebExtension backend. * * Sets up all event handlers and other machinery. */ export async function wxMain(): Promise { logger.trace("starting"); const afterWalletIsInitialized = reinitWallet(); platform.registerReloadOnNewVersion(); // Handlers for messages coming directly from the content // script on the page platform.listenToAllChannels(async (message) => { //wait until wallet is initialized await afterWalletIsInitialized; const result = await dispatch(message); return result; }); platform.registerAllIncomingConnections(); try { platform.registerOnInstalled(() => { platform.openWalletPage("/welcome"); // try { platform.registerTalerHeaderListener(parseTalerUriAndRedirect); } catch (e) { logger.error("could not register header listener", e); } }); } catch (e) { console.error(e); } // On platforms that support it, also listen to external // modification of permissions. platform.getPermissionsApi().addPermissionsListener((perm, lastError) => { if (lastError) { logger.error( `there was a problem trying to get permission ${perm}`, lastError, ); return; } platform.registerTalerHeaderListener(parseTalerUriAndRedirect); }); }