@lockerpm/desktop-service 1.0.0

package/lib/esm/abstractions/crypto.service.js

@@ -0,0 +1,165 @@
+"use strict";
+// @ts-nocheck
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptedObject = exports.EncString = exports.SymmetricCryptoKey = exports.EncryptionType = exports.KdfType = exports.AES = exports.ECDH = void 0;
+const utils_1 = require("../misc/utils");
+exports.ECDH = {
+    name: 'ECDH',
+    namedCurve: 'P-384',
+};
+exports.AES = {
+    name: 'AES-CBC',
+};
+// -------------- CORE --------------
+var KdfType;
+(function (KdfType) {
+    KdfType[KdfType["PBKDF2_SHA256"] = 0] = "PBKDF2_SHA256";
+})(KdfType || (exports.KdfType = KdfType = {}));
+var EncryptionType;
+(function (EncryptionType) {
+    EncryptionType[EncryptionType["AesCbc256_B64"] = 0] = "AesCbc256_B64";
+    EncryptionType[EncryptionType["AesCbc128_HmacSha256_B64"] = 1] = "AesCbc128_HmacSha256_B64";
+    EncryptionType[EncryptionType["AesCbc256_HmacSha256_B64"] = 2] = "AesCbc256_HmacSha256_B64";
+    EncryptionType[EncryptionType["Rsa2048_OaepSha256_B64"] = 3] = "Rsa2048_OaepSha256_B64";
+    EncryptionType[EncryptionType["Rsa2048_OaepSha1_B64"] = 4] = "Rsa2048_OaepSha1_B64";
+    EncryptionType[EncryptionType["Rsa2048_OaepSha256_HmacSha256_B64"] = 5] = "Rsa2048_OaepSha256_HmacSha256_B64";
+    EncryptionType[EncryptionType["Rsa2048_OaepSha1_HmacSha256_B64"] = 6] = "Rsa2048_OaepSha1_HmacSha256_B64";
+})(EncryptionType || (exports.EncryptionType = EncryptionType = {}));
+class SymmetricCryptoKey {
+    key;
+    encKey;
+    macKey;
+    encType;
+    keyB64;
+    encKeyB64;
+    macKeyB64;
+    meta;
+    constructor(key, encType) {
+        if (key == null) {
+            throw new Error('Must provide key');
+        }
+        if (encType == null) {
+            if (key.byteLength === 32) {
+                encType = EncryptionType.AesCbc256_B64;
+            }
+            else if (key.byteLength === 64) {
+                encType = EncryptionType.AesCbc256_HmacSha256_B64;
+            }
+            else {
+                throw new Error('Unable to determine encType.');
+            }
+        }
+        this.key = key;
+        this.encType = encType;
+        if (encType === EncryptionType.AesCbc256_B64 && key.byteLength === 32) {
+            this.encKey = key;
+            this.macKey = undefined;
+        }
+        else if (encType === EncryptionType.AesCbc128_HmacSha256_B64 && key.byteLength === 32) {
+            this.encKey = key.slice(0, 16);
+            this.macKey = key.slice(16, 32);
+        }
+        else if (encType === EncryptionType.AesCbc256_HmacSha256_B64 && key.byteLength === 64) {
+            this.encKey = key.slice(0, 32);
+            this.macKey = key.slice(32, 64);
+        }
+        else {
+            throw new Error('Unsupported encType/key length.');
+        }
+        if (this.key != null) {
+            this.keyB64 = utils_1.Utils.fromBufferToB64(this.key);
+        }
+        if (this.encKey != null) {
+            this.encKeyB64 = utils_1.Utils.fromBufferToB64(this.encKey);
+        }
+        if (this.macKey != null) {
+            this.macKeyB64 = utils_1.Utils.fromBufferToB64(this.macKey);
+        }
+    }
+}
+exports.SymmetricCryptoKey = SymmetricCryptoKey;
+class EncString {
+    encryptedString;
+    encryptionType;
+    decryptedValue;
+    data;
+    iv;
+    mac;
+    constructor(encryptedStringOrType, data, iv, mac) {
+        if (data != null) {
+            // data and header
+            const encType = encryptedStringOrType;
+            if (iv != null) {
+                this.encryptedString = encType + '.' + iv + '|' + data;
+            }
+            else {
+                this.encryptedString = encType + '.' + data;
+            }
+            // mac
+            if (mac != null) {
+                this.encryptedString += '|' + mac;
+            }
+            this.encryptionType = encType;
+            this.data = data;
+            this.iv = iv;
+            this.mac = mac;
+            return;
+        }
+        this.encryptedString = encryptedStringOrType;
+        if (!this.encryptedString) {
+            return;
+        }
+        const headerPieces = this.encryptedString.split('.');
+        let encPieces = null;
+        if (headerPieces.length === 2) {
+            try {
+                this.encryptionType = parseInt(headerPieces[0]);
+                encPieces = headerPieces[1].split('|');
+            }
+            catch (e) {
+                return;
+            }
+        }
+        else {
+            encPieces = this.encryptedString.split('|');
+            this.encryptionType =
+                encPieces.length === 3
+                    ? EncryptionType.AesCbc128_HmacSha256_B64
+                    : EncryptionType.AesCbc256_B64;
+        }
+        switch (this.encryptionType) {
+            case EncryptionType.AesCbc128_HmacSha256_B64:
+            case EncryptionType.AesCbc256_HmacSha256_B64:
+                if (encPieces.length !== 3) {
+                    return;
+                }
+                this.iv = encPieces[0];
+                this.data = encPieces[1];
+                this.mac = encPieces[2];
+                break;
+            case EncryptionType.AesCbc256_B64:
+                if (encPieces.length !== 2) {
+                    return;
+                }
+                this.iv = encPieces[0];
+                this.data = encPieces[1];
+                break;
+            case EncryptionType.Rsa2048_OaepSha256_B64:
+            case EncryptionType.Rsa2048_OaepSha1_B64:
+                if (encPieces.length !== 1) {
+                    return;
+                }
+                this.data = encPieces[0];
+                break;
+            default:
+        }
+    }
+}
+exports.EncString = EncString;
+class EncryptedObject {
+    iv;
+    data;
+    mac;
+    key;
+}
+exports.EncryptedObject = EncryptedObject;

package/lib/esm/abstractions/errors.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERRORS = exports.ServiceError = void 0;
+class ServiceError extends Error {
+    code;
+    message;
+    rawError;
+    constructor(code, rawError) {
+        super(rawError);
+        this.rawError = rawError;
+        this.code = code;
+        const rawMessage = rawError?.response?.data?.message ||
+            rawError?.message ||
+            rawError?.toString() ||
+            'Unknown error';
+        this.message = code === '0000' ? rawMessage : exports.ERRORS[code].message;
+    }
+    static fromError(rawError) {
+        const message = rawError?.response?.data?.message ||
+            rawError?.message ||
+            rawError?.toString() ||
+            'Unknown error';
+        const error = ERRORS_LIST.filter((e) => !!e.signatures).find((e) => e.signatures?.some((signature) => message.toLowerCase().includes(signature)));
+        if (error) {
+            return new ServiceError(error.code, rawError);
+        }
+        return new ServiceError('0000', rawError);
+    }
+}
+exports.ServiceError = ServiceError;
+exports.ERRORS = {
+    '0000': {
+        message: 'Unspecified error',
+    },
+    // API
+    '1000': {
+        message: 'API error',
+    },
+    '1001': {
+        message: 'API token not found',
+    },
+    '1002': {
+        message: 'Passwordless is not enabled',
+    },
+    // FIDO
+    '2001': {
+        message: 'Cannot connect to fido key',
+    },
+    '2002': {
+        message: 'Cannot create credential, key return empty secret',
+    },
+    '2003': {
+        message: 'Invalid PIN',
+        signatures: ['pin invalid'],
+    },
+    '2004': {
+        message: 'Cannot find relying party',
+        signatures: ['no rp'],
+    },
+    '2005': {
+        message: 'Cannot find any valid credential in this key',
+    },
+    '2006': {
+        message: 'Cannot find the required credential in this key',
+        signatures: ['no credentials'],
+    },
+    '2007': {
+        message: 'Cannot use fingerprint, please use PIN instead',
+        signatures: ['unsupported option', 'pin required'],
+    },
+    '2008': {
+        message: 'PIN validation failed to many times, key is blocked',
+        signatures: ['pin auth blocked'],
+    },
+    '2009': {
+        message: 'Failed to verify fingerprint',
+        signatures: ['keep alive cancel'],
+    },
+    '2010': {
+        message: 'List credentials is not supported on this key',
+        signatures: ['failed to get relying party info: invalid command'],
+    },
+    '2011': {
+        message: 'FIDO action timed out',
+        signatures: ['failed to get assertion: action timed out'],
+    },
+    // PAIRING
+    '3001': {
+        message: 'Client is not confirmed',
+    },
+    // SOCKET
+    '4001': {
+        message: 'Client not found',
+    },
+    '4002': {
+        message: 'Cannot broadcast secure message',
+    },
+}; // as { [code: string]: { message: string; signatures?: string[] } }
+// @ts-ignore
+const ERRORS_LIST = Object.keys(exports.ERRORS).map((code) => ({ code, ...exports.ERRORS[code] }));

package/lib/esm/abstractions/event.service.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/esm/abstractions/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/esm/abstractions/socket.service.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOutgoingSocketMessage = void 0;
+function buildOutgoingSocketMessage(message, data, secure) {
+    return {
+        message,
+        data,
+        secure,
+    };
+}
+exports.buildOutgoingSocketMessage = buildOutgoingSocketMessage;

package/lib/esm/abstractions/storage.service.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/esm/index.mjs

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DesktopService = exports.ServiceErrors = void 0;
+const socket_service_1 = require("./abstractions/socket.service");
+const api_service_1 = require("./services/api.service");
+const user_service_1 = require("./services/user.service");
+const crypto_service_1 = require("./services/crypto.service");
+const event_service_1 = require("./services/event.service");
+const fido_service_1 = require("./services/fido.service");
+const grpc_service_1 = require("./services/grpc.service");
+const log_service_1 = require("./services/log.service");
+const pairing_service_1 = require("./services/pairing.service");
+const socket_service_2 = require("./services/socket.service");
+const errors_1 = require("./abstractions/errors");
+const fido_1 = require("./usecases/fido");
+const cache_service_1 = require("./services/cache.service");
+exports.ServiceErrors = errors_1.ERRORS;
+class DesktopService {
+    apiService;
+    fidoService;
+    logService;
+    pairingService;
+    socketService;
+    userService;
+    grpcService;
+    cacheService;
+    eventService;
+    storageService;
+    cryptoService;
+    _interval = null;
+    // Constructor
+    constructor(params) {
+        const { baseApiUrl, logLevel, storageService, ssl, unsafe, apiHeaders, serviceAlias, socketSsl, } = params;
+        this.cryptoService = new crypto_service_1.CryptoService();
+        this.storageService = storageService;
+        this.logService = new log_service_1.LogService(logLevel);
+        this.eventService = new event_service_1.EventService(this.logService);
+        this.apiService = new api_service_1.ApiService({
+            baseUrl: baseApiUrl,
+            logger: this.logService,
+            headers: apiHeaders,
+        });
+        this.grpcService = new grpc_service_1.GRPCService({
+            logger: this.logService,
+            cryptoService: this.cryptoService,
+            apiService: this.apiService,
+        }, {
+            ssl,
+            unsafe,
+            serviceAlias: serviceAlias || '',
+        });
+        this.fidoService = new fido_service_1.FidoService(this.logService, this.eventService, this.grpcService);
+        this.pairingService = new pairing_service_1.PairingService({
+            cryptoService: this.cryptoService,
+            eventService: this.eventService,
+            storageService: this.storageService,
+            logger: this.logService,
+            grpcService: this.grpcService,
+        });
+        this.userService = new user_service_1.UserService({
+            logger: this.logService,
+            storageService: this.storageService,
+            grpcService: this.grpcService,
+        });
+        this.socketService = new socket_service_2.SocketService({
+            logger: this.logService,
+            pairingService: this.pairingService,
+            userService: this.userService,
+            eventService: this.eventService,
+            ssl: socketSsl,
+            serviceAlias: serviceAlias || '',
+        });
+        this.cacheService = new cache_service_1.CacheService(this.logService, this.grpcService);
+        this.waitUntilReady();
+    }
+    // ---------------------- READY STATE ----------------------
+    get isReady() {
+        const requiredService = [
+            this.grpcService,
+            this.userService,
+            this.pairingService,
+            this.socketService,
+        ];
+        return requiredService.reduce((isReady, service) => isReady && service.isReady, true);
+    }
+    waitUntilReady() {
+        return new Promise((resolve) => {
+            const step = 500;
+            const timeout = 5000;
+            let counter = 0;
+            if (this._interval) {
+                clearInterval(this._interval);
+            }
+            this._interval = setInterval(() => {
+                if (this.isReady) {
+                    this.eventService.emit('serviceReady', undefined);
+                    clearInterval(this._interval);
+                    resolve(true);
+                    return;
+                }
+                counter += step;
+                if (counter >= timeout) {
+                    this.logService.error(`Service not ready after ${timeout} ms`);
+                    clearInterval(this._interval);
+                    resolve(false);
+                }
+            }, step);
+        });
+    }
+    resetSocket() {
+        return this.socketService.initSocket();
+    }
+    resetGRPC() {
+        return this.grpcService.initConnection();
+    }
+    // ---------------------- FIDO ----------------------
+    setApiToken(token) {
+        this.apiService.setToken(token);
+    }
+    getFidoDeviceList() {
+        return this.fidoService.getDeviceList();
+    }
+    setNewPasswordless(params) {
+        return (0, fido_1.setNewPasswordless)(params, {
+            apiService: this.apiService,
+            fidoService: this.fidoService,
+        });
+    }
+    deletePasswordless() {
+        return this.apiService.deletePasswordlessCredential();
+    }
+    setBackupPasswordless(params) {
+        return (0, fido_1.setBackupPasswordless)(params, {
+            apiService: this.apiService,
+            fidoService: this.fidoService,
+            cryptoService: this.cryptoService,
+        });
+    }
+    async listAllPasswordless(email) {
+        const [mainKey, backupKeys] = await Promise.all([
+            this.apiService.getPasswordlessCredentials(email),
+            this.apiService.listBackupPasswordlessCredentials(),
+        ]);
+        const res = [...backupKeys];
+        if (mainKey.credential_id) {
+            res.push({
+                id: 'primary',
+                name: mainKey.name || '',
+                creation_date: mainKey.creation_date,
+                last_use_date: mainKey.last_use_date,
+                master_password_hash: '',
+                key: '',
+                fd_credential_id: mainKey.credential_id,
+                fd_random: mainKey.random || '',
+                isPrimary: true,
+                type: mainKey.type,
+            });
+        }
+        return res;
+    }
+    async listBackupPasswordless() {
+        return this.apiService.listBackupPasswordlessCredentials();
+    }
+    async deleteBackupPasswordless(id) {
+        return this.apiService.deleteBackupPasswordlessCredential(id);
+    }
+    getPasswordless(params) {
+        return (0, fido_1.getPasswordless)(params, {
+            apiService: this.apiService,
+            fidoService: this.fidoService,
+            logService: this.logService,
+        });
+    }
+    // ---------------------- PAIRING ----------------------
+    async confirmPairingClient(clientId, clientType) {
+        await this.pairingService.confirmPairingClient(clientId, clientType === 'extension');
+        this.socketService.sendMessageToClient(clientId, (0, socket_service_1.buildOutgoingSocketMessage)('pairingConfirmed', undefined));
+    }
+    async resetPairingCode(clientId) {
+        this.socketService.sendMessageToClient(clientId, (0, socket_service_1.buildOutgoingSocketMessage)('resetPairing', undefined));
+    }
+    async sendCustomMessage(data) {
+        this.socketService.broadcastMessageToAll((0, socket_service_1.buildOutgoingSocketMessage)('customMessage', data));
+    }
+    getCacheData() {
+        return this.cacheService.getCache();
+    }
+    setCacheData(data) {
+        return this.cacheService.setCache(data);
+    }
+    // ---------------------- USER ----------------------
+    getCurrentUser() {
+        return this.userService.getCurrentUser();
+    }
+    async login(params) {
+        await this.userService.login(params);
+        this.socketService.broadcastMessageToAll((0, socket_service_1.buildOutgoingSocketMessage)('userLogin', { email: params.email }));
+    }
+    async logout() {
+        const currentUser = { ...this.userService.currentUser };
+        if (currentUser?.email) {
+            await this.userService.logout();
+            this.socketService.broadcastMessageToAll((0, socket_service_1.buildOutgoingSocketMessage)('userLogout', { email: currentUser.email }));
+        }
+    }
+    async lock() {
+        const currentUser = { ...this.userService.currentUser };
+        if (currentUser?.email) {
+            await this.userService.lock();
+            this.socketService.broadcastMessageToAll((0, socket_service_1.buildOutgoingSocketMessage)('userLock', { email: currentUser.email }));
+        }
+    }
+    // ---------------------- EVENTS ----------------------
+    on(event, handler) {
+        return this.eventService.on(event, handler);
+    }
+    once(event, handler) {
+        return this.eventService.once(event, handler);
+    }
+    removeListener(event, handler) {
+        this.eventService.removeListener(event, handler);
+    }
+    removeAllListeners() {
+        this.eventService.removeAllListeners();
+    }
+}
+exports.DesktopService = DesktopService;

package/lib/esm/misc/config.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRPC_PING_TIMEOUT = exports.GRPC_CONNECTION_TIMEOUT = exports.WEBSOCKET_SSL_PORTS = exports.WEBSOCKET_PORTS = exports.HTTP_PORTS = void 0;
+exports.HTTP_PORTS = [
+    14411, 14110, 15611, 14412, 16311, 14514, 14515, 14413, 14401, 14100, 15601, 14402, 16301, 14504,
+    14505, 14403,
+];
+exports.WEBSOCKET_PORTS = [
+    10040, 10124, 10978, 11307, 11792, 21792, 10041, 10125, 10979, 11308, 11793, 21793,
+];
+exports.WEBSOCKET_SSL_PORTS = [
+    20040, 20124, 20978, 21307, 21792, 22792, 20041, 20125, 20979, 21308, 21793, 22793,
+];
+exports.GRPC_CONNECTION_TIMEOUT = 1500;
+exports.GRPC_PING_TIMEOUT = 1000;

package/lib/esm/misc/utils.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = void 0;
+const os_1 = __importDefault(require("os"));
+class Utils {
+    static fromHexToArray(str) {
+        return new Uint8Array(Buffer.from(str, 'hex'));
+    }
+    static fromBufferToHex(buffer) {
+        return Buffer.from(buffer).toString('hex');
+    }
+    static fromBufferToB64(buffer) {
+        return Buffer.from(buffer).toString('base64');
+    }
+    static fromUtf8ToArray(str) {
+        return new Uint8Array(Buffer.from(str, 'utf8'));
+    }
+    static fromB64ToArray(str) {
+        return new Uint8Array(Buffer.from(str, 'base64'));
+    }
+    static getCurrentOS() {
+        const platform = os_1.default.platform();
+        const arc = os_1.default.arch();
+        let _os = 'linux';
+        if (platform === 'darwin') {
+            _os = arc === 'x64' ? 'mac-x64' : 'mac-arm64';
+        }
+        if (platform === 'win32') {
+            _os = 'windows';
+        }
+        return _os;
+    }
+}
+exports.Utils = Utils;

package/lib/esm/proto/google/api/annotations.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });