@binsky/passman-client-ts 0.1.0-7

package/lib/Model/Credential.js

@@ -0,0 +1,594 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PassmanCrypto_1 = require("../Service/PassmanCrypto");
+const DownloadService_1 = require("../Service/DownloadService");
+const File_1 = require("./File");
+const html_escaper_1 = require("html-escaper");
+const SharingACL_1 = require("./SharingACL");
+class Credential {
+    vault;
+    server;
+    ENCRYPTED_FIELDS = ['description', 'username', 'password', 'files', 'custom_fields', 'otp', 'email', 'tags', 'url', 'compromised', 'shared_key'];
+    encryptedData;
+    decryptedDataCache;
+    sharedCredentialEncryptionKey; // this is set if the credential is shared with us (injected by ShareService)
+    foundUnspecifiedEncryptionError = false;
+    // can be used to re-encrypt credential data, if the original vault key is not changed yet
+    overwriteVaultKey = undefined;
+    constructor(vault, server, encryptedData = undefined) {
+        this.vault = vault;
+        this.server = server;
+        this.encryptedData = encryptedData;
+        this.decryptedDataCache = {};
+        if (encryptedData === undefined) {
+            this.encryptedData = {};
+            this.initializeAllFields();
+        }
+        this.vault_id = vault.vaultId;
+    }
+    initializeAllFields() {
+        this.user_id = null;
+        this.vault_id = null;
+        this.label = null;
+        this.description = null;
+        this.tags = [];
+        this.email = null;
+        this.username = null;
+        this.password = null;
+        this.url = null;
+        this.files = [];
+        this.custom_fields = [];
+        this.otp = {};
+        this.compromised = null;
+        this.shared_key = null;
+        this.favicon = null;
+        this.icon = null;
+        this.renew_interval = null;
+        this.expire_time = 0;
+        this.delete_time = 0;
+        this.hidden = null;
+        this.created = null;
+        this.changed = null;
+        this.set_share_key = null;
+        this.skip_revision = null;
+    }
+    /**
+     * Save new credential on the server.
+     * The current credential object will be updated with the server response data if possible.
+     */
+    async save() {
+        let credentialResponse = await this.server.postJson('/credentials', this.encryptedData, (response) => {
+            this.server.logger.onError(response.message);
+        });
+        if (credentialResponse) {
+            this.encryptedData = credentialResponse;
+            this.decryptedDataCache = {};
+        }
+        return credentialResponse;
+    }
+    /**
+     * Update / edit an existing credential on the server.
+     * The current credential object will be updated with the server response data if possible.
+     */
+    async update() {
+        if (this.acl === undefined || this.acl.permissions.hasPermission(SharingACL_1.SharingACL.permissions.WRITE)) {
+            let credentialResponse = await this.server.postJson('/credentials/' + this.guid, this.encryptedData, (response) => {
+                this.server.logger.onError(response.message);
+            }, 'PATCH');
+            if (credentialResponse) {
+                if (this.encryptedData.acl) {
+                    credentialResponse.acl = this.encryptedData.acl;
+                }
+                this.encryptedData = credentialResponse;
+                this.decryptedDataCache = {};
+            }
+            return credentialResponse;
+        }
+    }
+    /**
+     * Refresh the local credential data based on the server, using the credentials guid.
+     * It is not supported to do that for credentials, shared with us.
+     */
+    async refresh() {
+        if (this.sharedCredentialEncryptionKey) {
+            // credential is shared with us
+            // no credential refresh possible, since there is no backend api to do that
+        }
+        else {
+            let credentialResponse = await this.server.getJson('/credentials/' + this.guid, (response) => {
+                this.server.logger.onError(response.message);
+            });
+            if (credentialResponse) {
+                this.encryptedData = credentialResponse;
+                this.decryptedDataCache = {};
+            }
+            return credentialResponse;
+        }
+    }
+    /**
+     * Destroys the credential on the server and removes itself from its local vault.
+     */
+    async destroy() {
+        if (this.acl === undefined || this.acl.permissions.hasPermission(SharingACL_1.SharingACL.permissions.WRITE)) {
+            let credentialResponse = await this.server.delete('/credentials/' + this.guid, (response) => {
+                this.server.logger.onError(response.message);
+            });
+            const pos = this.vault.credentials.indexOf(this);
+            this.vault.credentials.splice(pos, 1);
+            return credentialResponse;
+        }
+    }
+    clearDecryptedDataCache() {
+        this.decryptedDataCache = {};
+    }
+    /**
+     * Create a credential object based on its encrypted data.
+     * @param data
+     * @param vault
+     * @param server
+     */
+    static async fromData(data, vault, server) {
+        return new Credential(vault, server, data);
+    }
+    /**
+     * Create a credential object based on its guid. This will fetch the current credential data from the server.
+     * @param guid
+     * @param vault
+     * @param server
+     */
+    static async fromGuid(guid, vault, server) {
+        let cred = new Credential(vault, server);
+        cred.guid = guid;
+        await cred.refresh();
+        return cred;
+    }
+    async getRevisions() {
+        return await this.server.getJson('/credentials/' + this.guid + '/revision', (response) => {
+            this.server.logger.onError(response.message);
+        });
+    }
+    /**
+     * Update credential (encryptedData store) with the new values, if they have changed.
+     * This does not update the servers credential instance.
+     * @param decryptedCredentialData
+     */
+    updateData(decryptedCredentialData) {
+        // todo: fill Interfaces folder
+        Object.keys(decryptedCredentialData).forEach((key) => {
+            if (key !== 'files' ||
+                (key === 'files' &&
+                    this.acl === undefined ||
+                    this.acl.permissions.hasPermission(SharingACL_1.SharingACL.permissions.FILES))) {
+                if (this.ENCRYPTED_FIELDS.indexOf(key) > -1) {
+                    // todo: improve check if array or object types have changed
+                    if (this.encryptedData[key] !== decryptedCredentialData[key] || typeof decryptedCredentialData[key] !== 'string') {
+                        if (key === 'shared_key') {
+                            // this special field is not encrypted, if it only contains a null value, since it won't be json stringified
+                            if (decryptedCredentialData[key] !== undefined && decryptedCredentialData[key] !== null && decryptedCredentialData[key] !== 'null' && decryptedCredentialData[key] !== '') {
+                                this.encryptedData[key] = decryptedCredentialData[key];
+                            }
+                        }
+                        else {
+                            this.setEncryptFieldData(key, decryptedCredentialData[key]);
+                        }
+                    }
+                }
+                else {
+                    this.encryptedData[key] = decryptedCredentialData[key];
+                }
+            }
+        });
+    }
+    exportData() {
+        return {
+            user_id: this.user_id,
+            vault_id: this.vault_id,
+            label: this.label,
+            description: this.description,
+            tags: this.tags,
+            email: this.email,
+            username: this.username,
+            password: this.password,
+            url: this.url,
+            files: (this.acl === undefined || this.acl.permissions.hasPermission(SharingACL_1.SharingACL.permissions.FILES)) ? this.files : [],
+            custom_fields: this.custom_fields,
+            otp: this.otp,
+            compromised: this.compromised,
+            shared_key: this.shared_key,
+            favicon: this.favicon,
+            icon: this.icon,
+            renew_interval: this.renew_interval,
+            expire_time: this.expire_time,
+            delete_time: this.delete_time,
+            hidden: this.hidden,
+            created: this.created,
+            changed: this.changed,
+            set_share_key: this.set_share_key,
+            skip_revision: this.skip_revision
+        };
+    }
+    /**
+     * Creates a local 100% clone of the current credential.
+     */
+    clone() {
+        const newCredential = new Credential(this.vault, this.server, this.encryptedData);
+        newCredential.sharedCredentialEncryptionKey = this.sharedCredentialEncryptionKey;
+        return newCredential;
+    }
+    /**
+     * Check whether the credential has a valid shared_key.
+     * If true, it is a credential, that's encrypted with the decrypted shared_key field content.
+     */
+    hasValidSharedKey() {
+        return this.encryptedData.shared_key !== undefined
+            && this.encryptedData.shared_key !== null
+            && this.encryptedData.shared_key !== 'null'
+            && this.encryptedData.shared_key !== '';
+    }
+    /**
+     * Creates a local 100% clone of the current credential and re-encrypts it with the given key.
+     */
+    reEncryptAsClone(newVaultKey) {
+        const newCredential = this.clone();
+        if (this.hasValidSharedKey()) {
+            // only re-encrypt the shared key, if the credential is shared and not encrypted with the vault key like default credentials
+            const decrypted_shared_key = newCredential.shared_key;
+            newCredential.set_share_key = true;
+            newCredential.skip_revision = true;
+            newCredential.overwriteVaultKey = newVaultKey;
+            newCredential.encryptedData.shared_key = PassmanCrypto_1.PassmanCrypto.encryptString(decrypted_shared_key, newVaultKey);
+        }
+        else {
+            // default (100% owned) credential
+            const decryptedCredentialData = newCredential.exportData();
+            newCredential.overwriteVaultKey = newVaultKey;
+            newCredential.updateData(decryptedCredentialData);
+            newCredential.skip_revision = true;
+        }
+        return newCredential;
+    }
+    getFieldEncryptionKey(fieldName = null) {
+        if (fieldName !== 'shared_key' &&
+            this.encryptedData.shared_key !== undefined &&
+            this.encryptedData.shared_key !== null &&
+            this.encryptedData.shared_key !== 'null' &&
+            this.encryptedData.shared_key !== '') {
+            // got a credential that is shared with others
+            if (this.decryptedDataCache.shared_key === undefined) {
+                this.decryptedDataCache.shared_key = PassmanCrypto_1.PassmanCrypto.decryptString(this.encryptedData.shared_key, this.overwriteVaultKey ?? this.vault.vaultKey);
+            }
+            if (this.decryptedDataCache.shared_key != null) {
+                // is this.encryptedData.shared_key is set, but a null value was encrypted, do not return it
+                return this.decryptedDataCache.shared_key;
+            }
+        }
+        if (this.sharedCredentialEncryptionKey !== undefined) {
+            return this.sharedCredentialEncryptionKey;
+        }
+        return this.overwriteVaultKey ?? this.vault.vaultKey;
+    }
+    /**
+     * Returns (json parsed) field data and decrypt / caches it if required.
+     *
+     * @param property key of ILEncryptedCredential
+     * @private
+     */
+    getCacheDecryptFieldData(property) {
+        if (this.ENCRYPTED_FIELDS.indexOf(property) > -1) {
+            if (this.decryptedDataCache[property] === undefined) {
+                if (this.encryptedData[property] === null) {
+                    this.decryptedDataCache[property] = null;
+                }
+                else {
+                    let decryptedData;
+                    try {
+                        decryptedData = PassmanCrypto_1.PassmanCrypto.decryptString(this.encryptedData[property], this.getFieldEncryptionKey(property));
+                        // check for non-json content field
+                        if (property === 'shared_key') {
+                            this.decryptedDataCache[property] = decryptedData;
+                        }
+                        else {
+                            this.decryptedDataCache[property] = JSON.parse(decryptedData);
+                        }
+                    }
+                    catch (e) {
+                        this.foundUnspecifiedEncryptionError = true;
+                        this.server.logger.anyError(e);
+                        this.server.logger.anyError(decryptedData);
+                        this.server.logger.onError('Failed to decrypt field: ' + property + ' of credential: ' + this.label);
+                    }
+                }
+            }
+            return this.decryptedDataCache[property];
+        }
+        // no need to cache nor json parse fields without encryption
+        return this.encryptedData[property];
+    }
+    /**
+     * Pass the plain field data so that it can be stored stringified and encrypted.
+     *
+     * @param property
+     * @param data
+     * @private
+     */
+    setEncryptFieldData(property, data) {
+        if (this.ENCRYPTED_FIELDS.indexOf(property) > -1) {
+            try {
+                // check for non-json content field
+                if (property === 'shared_key') {
+                    this.encryptedData[property] = PassmanCrypto_1.PassmanCrypto.encryptString(data, this.getFieldEncryptionKey(property));
+                }
+                else {
+                    this.encryptedData[property] = PassmanCrypto_1.PassmanCrypto.encryptString(JSON.stringify(data), this.getFieldEncryptionKey(property));
+                }
+            }
+            catch (e) {
+                this.foundUnspecifiedEncryptionError = true;
+                this.server.logger.anyError(e);
+                this.server.logger.onError('Failed to encrypt field: ' + property + ' of credential: ' + this.label);
+                return;
+            }
+            this.decryptedDataCache[property] = data;
+        }
+        else {
+            this.encryptedData[property] = data;
+        }
+    }
+    downloadFile(file, directDownload = true) {
+        if (file.filename === undefined || file.mimetype === undefined) {
+            return;
+        }
+        const key = this.getFieldEncryptionKey();
+        const logger = this.server.logger;
+        const callback = function (result) {
+            if (!result.hasOwnProperty('file_data')) {
+                logger.onError('Error downloading file (' + file.filename + '), you probably have insufficient permissions');
+                return;
+            }
+            try {
+                const file_data = PassmanCrypto_1.PassmanCrypto.decryptString(result.file_data, key);
+                if (directDownload) {
+                    DownloadService_1.DownloadService.download(file_data, (0, html_escaper_1.escape)(file.filename), file.mimetype);
+                }
+                else {
+                    return file_data;
+                }
+            }
+            catch (e) {
+                logger.anyError(e);
+                logger.onError('Failed to decrypt file: ' + file.filename);
+            }
+        };
+        if (!this.encryptedData.acl) {
+            return File_1.File.downloadFile(file, this.server).then(callback);
+        }
+        else {
+            return File_1.File.downloadSharedFile(this, file, this.server).then(callback);
+        }
+    }
+    /**
+     * Takes plain file data, encrypts and uploads it.
+     * This method does *not* add the file to the local credential files list!
+     * Adding it to the files list as well as a call to save() or update() is required to associate the file persistent with the credential.
+     * @param plainFile
+     */
+    encryptUploadFile(plainFile) {
+        try {
+            const encryptedFile = {
+                data: PassmanCrypto_1.PassmanCrypto.encryptString(plainFile.data, this.getFieldEncryptionKey()),
+                filename: PassmanCrypto_1.PassmanCrypto.encryptString(JSON.stringify(plainFile.filename), this.getFieldEncryptionKey()),
+                mimetype: plainFile.mimetype,
+                size: plainFile.size
+            };
+            const callback = function (uploadFileResponse) {
+                return uploadFileResponse;
+            };
+            if (!this.encryptedData.acl) {
+                return File_1.File.uploadFile(encryptedFile, this.server).then(callback);
+            }
+            else {
+                return File_1.File.uploadSharedFile(this, encryptedFile, this.server).then(callback);
+            }
+        }
+        catch (e) {
+            this.foundUnspecifiedEncryptionError = true;
+            this.server.logger.anyError(e);
+            this.server.logger.onError('Failed to encrypt new file (' + plainFile.filename + ') of credential: ' + this.label);
+        }
+    }
+    /**
+     * Deletes the given file from the server.
+     * This method does *not* delete the file from the local credential files list!
+     * @param file
+     */
+    deleteFile(file) {
+        return File_1.File.deleteFile(file, this.server);
+    }
+    getVaultGuid() {
+        return this.vault.guid;
+    }
+    getEncrypted() {
+        return this.encryptedData;
+    }
+    hasUnspecifiedEncryptionError() {
+        return this.foundUnspecifiedEncryptionError;
+    }
+    get credential_id() {
+        return this.encryptedData.credential_id;
+    }
+    set credential_id(value) {
+        this.encryptedData.credential_id = value;
+    }
+    get guid() {
+        return this.encryptedData.guid;
+    }
+    set guid(value) {
+        this.encryptedData.guid = value;
+    }
+    get user_id() {
+        return this.encryptedData.user_id;
+    }
+    set user_id(value) {
+        this.encryptedData.user_id = value;
+    }
+    get vault_id() {
+        return this.encryptedData.vault_id;
+    }
+    set vault_id(value) {
+        this.encryptedData.vault_id = value;
+    }
+    get label() {
+        return this.encryptedData.label;
+    }
+    set label(value) {
+        this.encryptedData.label = value;
+    }
+    get description() {
+        return this.getCacheDecryptFieldData('description');
+    }
+    set description(value) {
+        this.setEncryptFieldData('description', value);
+    }
+    get tags() {
+        return this.getCacheDecryptFieldData('tags');
+    }
+    set tags(value) {
+        this.setEncryptFieldData('tags', value);
+    }
+    get email() {
+        return this.getCacheDecryptFieldData('email');
+    }
+    set email(value) {
+        this.setEncryptFieldData('email', value);
+    }
+    get username() {
+        return this.getCacheDecryptFieldData('username');
+    }
+    set username(value) {
+        this.setEncryptFieldData('username', value);
+    }
+    get password() {
+        return this.getCacheDecryptFieldData('password');
+    }
+    set password(value) {
+        this.setEncryptFieldData('password', value);
+    }
+    get url() {
+        return this.getCacheDecryptFieldData('url');
+    }
+    set url(value) {
+        this.setEncryptFieldData('url', value);
+    }
+    get files() {
+        return this.getCacheDecryptFieldData('files');
+    }
+    set files(value) {
+        this.setEncryptFieldData('files', value);
+    }
+    get custom_fields() {
+        return this.getCacheDecryptFieldData('custom_fields');
+    }
+    set custom_fields(value) {
+        this.setEncryptFieldData('custom_fields', value);
+    }
+    get otp() {
+        return this.getCacheDecryptFieldData('otp');
+    }
+    set otp(value) {
+        this.setEncryptFieldData('otp', value);
+    }
+    get compromised() {
+        return this.getCacheDecryptFieldData('compromised');
+    }
+    set compromised(value) {
+        this.setEncryptFieldData('compromised', value);
+    }
+    /**
+     * This special field is not encrypted, if it only contains a null value.
+     */
+    get shared_key() {
+        if (this.encryptedData.shared_key !== undefined && this.encryptedData.shared_key !== null && this.encryptedData.shared_key !== 'null' && this.encryptedData.shared_key !== '') {
+            return this.getCacheDecryptFieldData('shared_key');
+        }
+        return null;
+    }
+    /**
+     * This special field is not encrypted, if it only contains a null value.
+     * @param value
+     */
+    set shared_key(value) {
+        if (value === null || value === '' || value === 'null') {
+            this.encryptedData.shared_key = null;
+        }
+        else {
+            this.setEncryptFieldData('shared_key', value);
+        }
+    }
+    get favicon() {
+        return this.encryptedData.favicon;
+    }
+    set favicon(value) {
+        this.encryptedData.favicon = value;
+    }
+    get icon() {
+        return this.encryptedData.icon;
+    }
+    set icon(value) {
+        this.encryptedData.icon = value;
+    }
+    get renew_interval() {
+        return this.encryptedData.renew_interval;
+    }
+    set renew_interval(value) {
+        this.encryptedData.renew_interval = value;
+    }
+    get expire_time() {
+        return this.encryptedData.expire_time;
+    }
+    set expire_time(value) {
+        this.encryptedData.expire_time = value;
+    }
+    get delete_time() {
+        return this.encryptedData.delete_time;
+    }
+    set delete_time(value) {
+        this.encryptedData.delete_time = value;
+    }
+    get hidden() {
+        return this.encryptedData.hidden;
+    }
+    set hidden(value) {
+        this.encryptedData.hidden = value;
+    }
+    get created() {
+        return this.encryptedData.created;
+    }
+    set created(value) {
+        this.encryptedData.created = value;
+    }
+    get changed() {
+        return this.encryptedData.changed;
+    }
+    set changed(value) {
+        this.encryptedData.changed = value;
+    }
+    get set_share_key() {
+        return this.encryptedData.set_share_key;
+    }
+    set set_share_key(value) {
+        this.encryptedData.set_share_key = value;
+    }
+    get skip_revision() {
+        return this.encryptedData.skip_revision;
+    }
+    set skip_revision(value) {
+        this.encryptedData.skip_revision = value;
+    }
+    get acl() {
+        return this.encryptedData.acl;
+    }
+    set acl(value) {
+        this.encryptedData.acl = value;
+    }
+}
+exports.default = Credential;

package/lib/Model/File.d.ts

@@ -0,0 +1,15 @@
+import NextcloudServer from "./NextcloudServer";
+import type Credential from "./Credential";
+import { FileInterface } from "../Interfaces/File/FileInterface";
+import { FileUploadResponseInterface } from "../Interfaces/File/FileUploadResponseInterface";
+import { DeleteFilesRequestBodyInterface } from "../Interfaces/File/DeleteFilesRequestBodyInterface";
+import { DeleteFilesResponseInterface } from "../Interfaces/File/DeleteFilesResponseInterface";
+export declare class File {
+    static downloadFile: (file: FileInterface, server: NextcloudServer) => Promise<any>;
+    static downloadSharedFile: (credential: Credential, file: FileInterface, server: NextcloudServer) => Promise<any>;
+    static uploadFile: (fileWithEncryptedFields: FileInterface, server: NextcloudServer) => Promise<void | FileUploadResponseInterface>;
+    static uploadSharedFile: (credential: Credential, fileWithEncryptedFields: FileInterface, server: NextcloudServer) => Promise<void | FileUploadResponseInterface>;
+    static updateFile: (fileWithEncryptedFields: FileInterface, server: NextcloudServer) => Promise<void | FileUploadResponseInterface>;
+    static deleteFile: (file: FileInterface, server: NextcloudServer) => Promise<any>;
+    static deleteFiles: (deleteFilesRequestBody: DeleteFilesRequestBodyInterface, server: NextcloudServer) => Promise<void | DeleteFilesResponseInterface>;
+}

package/lib/Model/File.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.File = void 0;
+class File {
+    static downloadFile = async (file, server) => {
+        return server.get('file/' + file.file_id, () => {
+        }).then(async (response) => {
+            if (response) {
+                return await response.json();
+            }
+            else {
+                return response;
+            }
+        });
+    };
+    static downloadSharedFile = async (credential, file, server) => {
+        return server.get('sharing/credential/' + credential.guid + '/file/' + file.guid, () => {
+        }).then(async (response) => {
+            if (response) {
+                return await response.json();
+            }
+            else {
+                return response;
+            }
+        });
+    };
+    static uploadFile = (fileWithEncryptedFields, server) => {
+        return server.postJson('file', fileWithEncryptedFields, () => {
+        });
+    };
+    static uploadSharedFile = (credential, fileWithEncryptedFields, server) => {
+        return server.postJson('sharing/credential/' + credential.guid + '/file', fileWithEncryptedFields, () => {
+        });
+    };
+    static updateFile = (fileWithEncryptedFields, server) => {
+        return server.postJson('file', fileWithEncryptedFields, () => {
+        }, 'PATCH');
+    };
+    static deleteFile = (file, server) => {
+        return server.delete('file/' + file.file_id, () => {
+        }).then(async (response) => {
+            if (response) {
+                return await response.json();
+            }
+            else {
+                return response;
+            }
+        });
+    };
+    static deleteFiles = (deleteFilesRequestBody, server) => {
+        return server.postJson('files/delete', deleteFilesRequestBody, () => {
+        });
+    };
+}
+exports.File = File;

package/lib/Model/NextcloudServer.d.ts

@@ -0,0 +1,27 @@
+import type { LoggingHandlerInterface } from "../Interfaces/LoggingHandlerInterface";
+import { NextcloudServerInterface } from "../Interfaces/NextcloudServer/NextcloudServerInterface";
+export default class NextcloudServer {
+    private serverData;
+    logger: LoggingHandlerInterface;
+    constructor(serverData: NextcloudServerInterface, logger: LoggingHandlerInterface);
+    getBaseUrl(): string;
+    setBaseUrl(value: string): string;
+    getUser(): string;
+    setUser(value: string): string;
+    getToken(): string;
+    setToken(value: string): string;
+    getApiUrl(): string;
+    private getEncodedLogin;
+    get: (endpoint: string, errorCallback: (response: Error) => void) => Promise<Response | void>;
+    getJson: <T>(endpoint: string, errorCallback: (response: Error) => void) => Promise<T | void>;
+    delete: (endpoint: string, errorCallback: (response: Error) => void) => Promise<Response | void>;
+    /**
+     * Do a post request.
+     *
+     * @param endpoint
+     * @param data will be converted to a json string
+     * @param errorCallback
+     * @param method
+     */
+    postJson: <T>(endpoint: string, data: [] | object | null, errorCallback: (response: Error) => void, method?: string) => Promise<T | void>;
+}