@wireapp/core 31.1.3 → 31.1.4

package/src/main/Account.js

@@ -0,0 +1,463 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2018 Wire Swiss GmbH
+ *
+ * This program 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 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Account = void 0;
+const http_status_codes_1 = require("http-status-codes");
+const api_client_1 = require("@wireapp/api-client");
+const auth_1 = require("@wireapp/api-client/src/auth/");
+const client_1 = require("@wireapp/api-client/src/client/");
+const tcp_1 = require("@wireapp/api-client/src/tcp/");
+const cryptobox = __importStar(require("@wireapp/cryptobox"));
+const store_engine_1 = require("@wireapp/store-engine");
+const events_1 = require("events");
+const logdown_1 = __importDefault(require("logdown"));
+const auth_2 = require("./auth/");
+const broadcast_1 = require("./broadcast/");
+const client_2 = require("./client/");
+const connection_1 = require("./connection/");
+const conversation_1 = require("./conversation/");
+const cryptography_1 = require("./cryptography/");
+const giphy_1 = require("./giphy/");
+const notification_1 = require("./notification/");
+const self_1 = require("./self/");
+const team_1 = require("./team/");
+const user_1 = require("./user/");
+const account_1 = require("./account/");
+const linkPreview_1 = require("./linkPreview");
+const encryptedStore_1 = require("./util/encryptedStore");
+const bazinga64_1 = require("bazinga64");
+const mls_1 = require("./mls");
+const messageSender_1 = require("./conversation/message/messageSender");
+var TOPIC;
+(function (TOPIC) {
+    TOPIC["ERROR"] = "Account.TOPIC.ERROR";
+})(TOPIC || (TOPIC = {}));
+const coreDefaultClient = {
+    classification: client_1.ClientClassification.DESKTOP,
+    cookieLabel: 'default',
+    model: '@wireapp/core',
+};
+class Account extends events_1.EventEmitter {
+    /**
+     * @param apiClient The apiClient instance to use in the core (will create a new new one if undefined)
+     * @param accountOptions
+     */
+    constructor(apiClient = new api_client_1.APIClient(), { createStore = () => undefined, nbPrekeys = 2, mlsConfig } = {}) {
+        super();
+        this.apiClient = apiClient;
+        this.backendFeatures = this.apiClient.backendFeatures;
+        this.mlsConfig = mlsConfig;
+        this.nbPrekeys = nbPrekeys;
+        this.createStore = createStore;
+        apiClient.on(api_client_1.APIClient.TOPIC.COOKIE_REFRESH, async (cookie) => {
+            if (cookie && this.storeEngine) {
+                try {
+                    await this.persistCookie(this.storeEngine, cookie);
+                }
+                catch (error) {
+                    this.logger.error(`Failed to save cookie: ${error.message}`, error);
+                }
+            }
+        });
+        this.logger = (0, logdown_1.default)('@wireapp/core/Account', {
+            logger: console,
+            markdown: false,
+        });
+    }
+    persistCookie(storeEngine, cookie) {
+        const entity = { expiration: cookie.expiration, zuid: cookie.zuid };
+        return storeEngine.updateOrCreate(auth_1.AUTH_TABLE_NAME, auth_1.AUTH_COOKIE_KEY, entity);
+    }
+    get clientId() {
+        return this.apiClient.validatedClientId;
+    }
+    get userId() {
+        return this.apiClient.validatedUserId;
+    }
+    /**
+     * Will register a new user to the backend
+     *
+     * @param registration The user's data
+     * @param clientType Type of client to create (temporary or permanent)
+     */
+    async register(registration, clientType) {
+        const context = await this.apiClient.register(registration, clientType);
+        await this.initServices(context);
+        return context;
+    }
+    /**
+     * Will init the core with an aleady existing client (both on backend and local)
+     * Will fail if local client cannot be found
+     *
+     * @param clientType The type of client the user is using (temporary or permanent)
+     * @param cookie The cookie to identify the user against backend (will use the browser's one if not given)
+     */
+    async init(clientType, cookie, initClient = true) {
+        var _a, _b, _c;
+        const context = await this.apiClient.init(clientType, cookie);
+        await this.initServices(context);
+        // Assumption: client gets only initialized once
+        if (initClient) {
+            await this.initClient({ clientType });
+            if (this.mlsConfig) {
+                // initialize schedulers for pending mls proposals once client is initialized
+                await ((_a = this.service) === null || _a === void 0 ? void 0 : _a.notification.checkExistingPendingProposals());
+                // initialize schedulers for renewing key materials
+                await ((_b = this.service) === null || _b === void 0 ? void 0 : _b.notification.checkForKeyMaterialsUpdate());
+                // initialize scheduler for syncing key packages with backend
+                await ((_c = this.service) === null || _c === void 0 ? void 0 : _c.notification.checkForKeyPackagesBackendSync());
+            }
+        }
+        return context;
+    }
+    /**
+     * Will log the user in with the given credential.
+     * Will also create the local client and store it in DB
+     *
+     * @param loginData The credentials of the user
+     * @param initClient Should the call also create the local client
+     * @param clientInfo Info about the client to create (name, type...)
+     */
+    async login(loginData, initClient = true, clientInfo = coreDefaultClient) {
+        this.resetContext();
+        auth_2.LoginSanitizer.removeNonPrintableCharacters(loginData);
+        const context = await this.apiClient.login(loginData);
+        await this.initServices(context);
+        if (initClient) {
+            await this.initClient(loginData, clientInfo);
+        }
+        return context;
+    }
+    /**
+     * Will try to get the load the local client from local DB.
+     * If clientInfo are provided, will also create the client on backend and DB
+     * If clientInfo are not provideo, the method will fail if local client cannot be found
+     *
+     * @param loginData User's credentials
+     * @param clientInfo Will allow creating the client if the local client cannot be found (else will fail if local client is not found)
+     * @param entropyData Additional entropy data
+     * @returns The local existing client or newly created client
+     */
+    async initClient(loginData, clientInfo, entropyData) {
+        var _a, _b;
+        if (!this.service) {
+            throw new Error('Services are not set.');
+        }
+        try {
+            const localClient = await this.loadAndValidateLocalClient(entropyData);
+            return { isNewClient: false, localClient };
+        }
+        catch (error) {
+            if (!clientInfo) {
+                // If no client info provided, the client should not be created
+                throw error;
+            }
+            // There was no client so we need to "create" and "register" a client
+            const notFoundInDatabase = error instanceof cryptobox.error.CryptoboxError ||
+                error.constructor.name === 'CryptoboxError' ||
+                error instanceof store_engine_1.error.RecordNotFoundError ||
+                error.constructor.name === store_engine_1.error.RecordNotFoundError.name;
+            const notFoundOnBackend = ((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === http_status_codes_1.StatusCodes.NOT_FOUND;
+            if (notFoundInDatabase) {
+                this.logger.log(`Could not find valid client in database "${(_b = this.storeEngine) === null || _b === void 0 ? void 0 : _b.storeName}".`);
+                return this.registerClient(loginData, clientInfo, entropyData);
+            }
+            if (notFoundOnBackend) {
+                this.logger.log('Could not find valid client on backend');
+                const client = await this.service.client.getLocalClient();
+                const shouldDeleteWholeDatabase = client.type === client_1.ClientType.TEMPORARY;
+                if (shouldDeleteWholeDatabase) {
+                    this.logger.log('Last client was temporary - Deleting database');
+                    if (this.storeEngine) {
+                        await this.storeEngine.clearTables();
+                    }
+                    const context = await this.apiClient.init(loginData.clientType);
+                    await this.initEngine(context);
+                    return this.registerClient(loginData, clientInfo, entropyData);
+                }
+                this.logger.log('Last client was permanent - Deleting cryptography stores');
+                await this.service.cryptography.deleteCryptographyStores();
+                return this.registerClient(loginData, clientInfo, entropyData);
+            }
+            throw error;
+        }
+    }
+    /**
+     * In order to be able to send MLS messages, the core needs a few information from the consumer.
+     * Namely:
+     * - is the current user allowed to administrate a specific conversation
+     * - what is the groupId of a conversation
+     * @param mlsCallbacks
+     */
+    configureMLSCallbacks(mlsCallbacks) {
+        var _a;
+        (_a = this.service) === null || _a === void 0 ? void 0 : _a.mls.configureMLSCallbacks(mlsCallbacks);
+    }
+    async initServices(context) {
+        this.storeEngine = await this.initEngine(context);
+        const accountService = new account_1.AccountService(this.apiClient);
+        const assetService = new conversation_1.AssetService(this.apiClient);
+        const cryptographyService = new cryptography_1.CryptographyService(this.apiClient, this.storeEngine, {
+            // We want to encrypt with fully qualified session ids, only if the backend is federated with other backends
+            useQualifiedIds: this.backendFeatures.isFederated,
+            nbPrekeys: this.nbPrekeys,
+        });
+        const clientService = new client_2.ClientService(this.apiClient, this.storeEngine, cryptographyService);
+        const mlsService = new mls_1.MLSService(this.mlsConfig, this.apiClient, () => this.coreCryptoClient);
+        const connectionService = new connection_1.ConnectionService(this.apiClient);
+        const giphyService = new giphy_1.GiphyService(this.apiClient);
+        const linkPreviewService = new linkPreview_1.LinkPreviewService(assetService);
+        const notificationService = new notification_1.NotificationService(this.apiClient, cryptographyService, mlsService, this.storeEngine);
+        const conversationService = new conversation_1.ConversationService(this.apiClient, cryptographyService, {
+            // We can use qualified ids to send messages as long as the backend supports federated endpoints
+            useQualifiedIds: this.backendFeatures.federationEndpoints,
+        }, notificationService, mlsService);
+        const selfService = new self_1.SelfService(this.apiClient);
+        const teamService = new team_1.TeamService(this.apiClient);
+        const broadcastService = new broadcast_1.BroadcastService(this.apiClient, cryptographyService);
+        const userService = new user_1.UserService(this.apiClient, broadcastService, conversationService, connectionService);
+        this.service = {
+            mls: mlsService,
+            account: accountService,
+            asset: assetService,
+            broadcast: broadcastService,
+            client: clientService,
+            connection: connectionService,
+            conversation: conversationService,
+            cryptography: cryptographyService,
+            giphy: giphyService,
+            linkPreview: linkPreviewService,
+            notification: notificationService,
+            self: selfService,
+            team: teamService,
+            user: userService,
+        };
+    }
+    async loadAndValidateLocalClient(entropyData) {
+        await this.service.cryptography.initCryptobox();
+        const loadedClient = await this.service.client.getLocalClient();
+        await this.apiClient.api.client.getClient(loadedClient.id);
+        this.apiClient.context.clientId = loadedClient.id;
+        if (this.mlsConfig) {
+            this.coreCryptoClient = await this.createMLSClient(loadedClient, this.apiClient.context, this.mlsConfig, entropyData);
+        }
+        return loadedClient;
+    }
+    async createMLSClient(client, context, mlsConfig, entropyData) {
+        if (!this.service) {
+            throw new Error('Services are not set.');
+        }
+        const coreCryptoKeyId = 'corecrypto-key';
+        const { CoreCrypto } = await Promise.resolve().then(() => __importStar(require('@wireapp/core-crypto')));
+        const dbName = this.generateSecretsDbName(context);
+        const secretStore = mlsConfig.secretsCrypto
+            ? await (0, encryptedStore_1.createCustomEncryptedStore)(dbName, mlsConfig.secretsCrypto)
+            : await (0, encryptedStore_1.createEncryptedStore)(dbName);
+        let key = await secretStore.getsecretValue(coreCryptoKeyId);
+        let isNewMLSDevice = false;
+        if (!key) {
+            key = window.crypto.getRandomValues(new Uint8Array(16));
+            await secretStore.saveSecretValue(coreCryptoKeyId, key);
+            // Keeping track that this device is a new MLS device (but can be an old proteus device)
+            isNewMLSDevice = true;
+        }
+        const { userId, domain } = this.apiClient.context;
+        const mlsClient = await CoreCrypto.init({
+            databaseName: `corecrypto-${this.generateDbName(context)}`,
+            key: bazinga64_1.Encoder.toBase64(key).asString,
+            clientId: `${userId}:${client.id}@${domain}`,
+            wasmFilePath: mlsConfig.coreCrypoWasmFilePath,
+            entropySeed: entropyData,
+        });
+        if (isNewMLSDevice) {
+            // If the device is new, we need to upload keypackages and public key to the backend
+            await this.service.mls.uploadMLSPublicKeys(await mlsClient.clientPublicKey(), client.id);
+            await this.service.mls.uploadMLSKeyPackages(await mlsClient.clientKeypackages(this.nbPrekeys), client.id);
+        }
+        return mlsClient;
+    }
+    async registerClient(loginData, clientInfo = coreDefaultClient, entropyData) {
+        if (!this.service) {
+            throw new Error('Services are not set.');
+        }
+        this.logger.info(`Creating new client {mls: ${!!this.mlsConfig}}`);
+        const registeredClient = await this.service.client.register(loginData, clientInfo, entropyData);
+        if (this.mlsConfig) {
+            this.coreCryptoClient = await this.createMLSClient(registeredClient, this.apiClient.context, this.mlsConfig, entropyData);
+        }
+        this.apiClient.context.clientId = registeredClient.id;
+        this.logger.info('Client is created');
+        await this.service.notification.initializeNotificationStream();
+        await this.service.client.synchronizeClients();
+        await this.service.cryptography.initCryptobox();
+        return { isNewClient: true, localClient: registeredClient };
+    }
+    resetContext() {
+        delete this.apiClient.context;
+        delete this.service;
+    }
+    /**
+     * Will logout the current user
+     * @param clearData if set to `true` will completely wipe any database that was created by the Account
+     */
+    async logout(clearData = false) {
+        if (clearData && this.coreCryptoClient) {
+            await this.coreCryptoClient.wipe();
+            await (0, encryptedStore_1.deleteEncryptedStore)(this.generateSecretsDbName(this.apiClient.context));
+        }
+        await this.apiClient.logout();
+        this.resetContext();
+    }
+    /**
+     * Will download and handle the notification stream since last stored notification id.
+     * Once the notification stream has been handled from backend, will then connect to the websocket and start listening to incoming events
+     *
+     * @param callbacks callbacks that will be called to handle different events
+     * @returns close a function that will disconnect from the websocket
+     */
+    async listen({ onEvent = () => { }, onConnected = () => { }, onConnectionStateChanged = () => { }, onNotificationStreamProgress = () => { }, onMissedNotifications = () => { }, dryRun = false, } = {}) {
+        if (!this.apiClient.context) {
+            throw new Error('Context is not set - please login first');
+        }
+        const handleEvent = async (payload, source) => {
+            const { mappedEvent } = payload;
+            switch (mappedEvent === null || mappedEvent === void 0 ? void 0 : mappedEvent.type) {
+                case conversation_1.PayloadBundleType.TIMER_UPDATE: {
+                    const { data: { message_timer }, conversation, } = payload.event;
+                    const expireAfterMillis = Number(message_timer);
+                    this.service.conversation.messageTimer.setConversationLevelTimer(conversation, expireAfterMillis);
+                    break;
+                }
+            }
+            onEvent(payload, source);
+            if (mappedEvent) {
+                this.emit(mappedEvent.type, payload.mappedEvent);
+            }
+        };
+        const handleNotification = async (notification, source) => {
+            var e_1, _a;
+            try {
+                const messages = this.service.notification.handleNotification(notification, source, dryRun);
+                try {
+                    for (var messages_1 = __asyncValues(messages), messages_1_1; messages_1_1 = await messages_1.next(), !messages_1_1.done;) {
+                        const message = messages_1_1.value;
+                        await handleEvent(message, source);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (messages_1_1 && !messages_1_1.done && (_a = messages_1.return)) await _a.call(messages_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            catch (error) {
+                this.logger.error(`Failed to handle notification ID "${notification.id}": ${error.message}`, error);
+            }
+        };
+        this.apiClient.transport.ws.removeAllListeners(tcp_1.WebSocketClient.TOPIC.ON_MESSAGE);
+        this.apiClient.transport.ws.on(tcp_1.WebSocketClient.TOPIC.ON_MESSAGE, notification => handleNotification(notification, conversation_1.PayloadBundleSource.WEBSOCKET));
+        this.apiClient.transport.ws.on(tcp_1.WebSocketClient.TOPIC.ON_STATE_CHANGE, onConnectionStateChanged);
+        const onBeforeConnect = async (abortHandler) => {
+            // Lock websocket in order to buffer any message that arrives while we handle the notification stream
+            this.apiClient.transport.ws.lock();
+            await this.service.notification.handleNotificationStream(async (notification, source, progress) => {
+                await handleNotification(notification, source);
+                onNotificationStreamProgress(progress);
+            }, onMissedNotifications, abortHandler);
+            // We can now unlock the websocket and let the new messages being handled and decrypted
+            this.apiClient.transport.ws.unlock();
+            // We need to wait for the notification stream to be fully handled before releasing the message sending queue.
+            // This is due to the nature of how message are encrypted, any change in mls epoch needs to happen before we start encrypting any kind of messages
+            (0, messageSender_1.resumeMessageSending)();
+            onConnected();
+        };
+        await this.apiClient.connect(onBeforeConnect);
+        return () => {
+            this.apiClient.transport.ws.removeAllListeners();
+            this.apiClient.disconnect();
+        };
+    }
+    generateDbName(context) {
+        const clientType = context.clientType === client_1.ClientType.NONE ? '' : `@${context.clientType}`;
+        return `wire@${this.apiClient.config.urls.name}@${context.userId}${clientType}`;
+    }
+    generateSecretsDbName(context) {
+        return `secrets-${this.generateDbName(context)}`;
+    }
+    async initEngine(context) {
+        const dbName = this.generateDbName(context);
+        this.logger.log(`Initialising store with name "${dbName}"...`);
+        const openDb = async () => {
+            const initializedDb = await this.createStore(dbName, context);
+            if (initializedDb) {
+                this.logger.log(`Initialized store with existing engine "${dbName}".`);
+                return initializedDb;
+            }
+            this.logger.log(`Initialized store with new memory engine "${dbName}".`);
+            const memoryEngine = new store_engine_1.MemoryEngine();
+            await memoryEngine.init(dbName);
+            return memoryEngine;
+        };
+        const storeEngine = await openDb();
+        const cookie = auth_1.CookieStore.getCookie();
+        if (cookie) {
+            await this.persistCookie(storeEngine, cookie);
+        }
+        return storeEngine;
+    }
+}
+exports.Account = Account;
+Account.TOPIC = TOPIC;
+//# sourceMappingURL=Account.js.map

package/src/main/CoreError.d.ts

@@ -0,0 +1,9 @@
+import { Notification } from '@wireapp/api-client/src/notification';
+export declare enum CoreError {
+    NOTIFICATION_ERROR = "CoreError.NOTIFICATION_ERROR"
+}
+export interface NotificationError {
+    error: Error;
+    notification: Notification;
+    type: CoreError.NOTIFICATION_ERROR;
+}

package/src/main/CoreError.js

@@ -0,0 +1,26 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2019 Wire Swiss GmbH
+ *
+ * This program 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 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreError = void 0;
+var CoreError;
+(function (CoreError) {
+    CoreError["NOTIFICATION_ERROR"] = "CoreError.NOTIFICATION_ERROR";
+})(CoreError = exports.CoreError || (exports.CoreError = {}));
+//# sourceMappingURL=CoreError.js.map

package/src/main/account/AccountService.d.ts

@@ -0,0 +1,7 @@
+import { APIClient } from '@wireapp/api-client';
+import { CallConfigData } from '@wireapp/api-client/src/account/CallConfigData';
+export declare class AccountService {
+    private readonly apiClient;
+    constructor(apiClient: APIClient);
+    getCallConfig(): Promise<CallConfigData>;
+}

package/src/main/account/AccountService.js

@@ -0,0 +1,33 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2020 Wire Swiss GmbH
+ *
+ * This program 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 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountService = void 0;
+const commons_1 = require("@wireapp/commons");
+class AccountService {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    getCallConfig() {
+        const iceCandidateLimit = commons_1.Runtime.isFirefox() ? 3 : undefined;
+        return this.apiClient.api.account.getCallConfig(iceCandidateLimit);
+    }
+}
+exports.AccountService = AccountService;
+//# sourceMappingURL=AccountService.js.map

package/src/main/account/AccountService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccountService.js","sourceRoot":"","sources":["AccountService.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;;AAGH,8CAAyC;AAGzC,MAAa,cAAc;IACzB,YAA6B,SAAoB;QAApB,cAAS,GAAT,SAAS,CAAW;IAAG,CAAC;IAErD,aAAa;QACX,MAAM,iBAAiB,GAAG,iBAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC9D,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC;IACrE,CAAC;CACF;AAPD,wCAOC"}

package/src/main/account/index.d.ts

@@ -0,0 +1 @@
+export * from './AccountService';

package/src/main/account/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2020 Wire Swiss GmbH
+ *
+ * This program 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 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AccountService"), exports);
+//# sourceMappingURL=index.js.map

package/src/main/account/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;;;;;;;;;;;;;;;AAEH,mDAAiC"}

package/src/main/auth/LoginSanitizer.d.ts

@@ -0,0 +1,5 @@
+import { LoginData } from '@wireapp/api-client/src/auth/';
+export declare class LoginSanitizer {
+    constructor();
+    static removeNonPrintableCharacters(loginData: LoginData): void;
+}

package/src/main/auth/LoginSanitizer.js

@@ -0,0 +1,41 @@
+"use strict";
+/*
+ * Wire
+ * Copyright (C) 2018 Wire Swiss GmbH
+ *
+ * This program 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 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoginSanitizer = void 0;
+class LoginSanitizer {
+    constructor() { }
+    static removeNonPrintableCharacters(loginData) {
+        const nonPrintableCharacters = /\s/gm;
+        if (loginData.email) {
+            loginData.email = loginData.email.replace(nonPrintableCharacters, '');
+        }
+        if (loginData.handle) {
+            loginData.handle = loginData.handle.replace(nonPrintableCharacters, '');
+        }
+        if (loginData.password) {
+            loginData.password = loginData.password.toString();
+        }
+        if (loginData.phone) {
+            loginData.phone = loginData.phone.toString().replace(nonPrintableCharacters, '');
+        }
+    }
+}
+exports.LoginSanitizer = LoginSanitizer;
+//# sourceMappingURL=LoginSanitizer.js.map

package/src/main/auth/index.d.ts

@@ -0,0 +1 @@
+export * from './LoginSanitizer';