@sap_oss/wdio-qmate-service 2.13.2 → 2.14.1

package/packages/qcrypt/dist/classes/Encrypter.d.ts

@@ -0,0 +1,49 @@
+import { EncodedData, EncryptionOptions, PrintOptions, PublicKey } from "../types/common";
+export default abstract class Encrypter {
+    /**
+     * @description Retrieves public keys from the file system and encrypts data for all of them.
+     * @param data Data to be encrypted.
+     * @param encryptionOptions Encryption options.
+     * @param printOptions Print options defining if the input and output is logged or not.
+     */
+    static encryptDataForAvailableKeys(data: string, encryptionOptions: EncryptionOptions, printOptions: PrintOptions): Array<EncodedData>;
+    /**
+     * @description Encrypts data for all passed public keys.
+     * @param data Data to be encrypted.
+     * @param encryptionOptions Encryption options.
+     * @param publicKeys Public keys for encryption.
+     */
+    static encryptDataForMultipleKeys(data: string, encryptionOptions: EncryptionOptions, publicKeys: Array<PublicKey>): Array<EncodedData>;
+    /**
+     * @description Retrieves the public keys from the file system.
+     * @param keyPath Path to the directory containing the public key.
+     * @returns An array containing public key objects.
+     */
+    private static _retrievePublicKeys;
+    /**
+     * @description Encrypts the given data with the provided public key and options.
+     * @param data Data to be encrypted.
+     * @param publicKey Public key for encryption.
+     * @param options Encryption options.
+     * @returns The encrypted data.
+     */
+    private static _encryptData;
+    /**
+     * @description Encrypts data using AES-256-CBC encryption and PBKDF2 key derivation. The key is derived from the repo URL or a static password.
+     * @param data Data to be encrypted.
+     * @param options Encryption options.
+     * @returns The AES encrypted data.
+     */
+    private static _encryptDataWithPassword;
+    /**
+     * @description Prints the input options and data to the console.
+     * @param options Encryption options.
+     * @param data Data to be encrypted.
+     */
+    private static _printInput;
+    /**
+     * @description Prints the output data and metadata to the console for multiple pieces of data.
+     * @param encodedDataList An array of encoded data objects containing root and encodedData.
+     */
+    private static _printOutput;
+}

package/packages/qcrypt/dist/classes/Encrypter.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Imports
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const Util_1 = __importDefault(require("./helper/Util"));
+const ErrorHandler_1 = __importDefault(require("./helper/ErrorHandler"));
+// Constants
+const common_1 = require("../constants/common");
+class Encrypter {
+    // ========================== Public functions ==========================
+    /**
+     * @description Retrieves public keys from the file system and encrypts data for all of them.
+     * @param data Data to be encrypted.
+     * @param encryptionOptions Encryption options.
+     * @param printOptions Print options defining if the input and output is logged or not.
+     */
+    static encryptDataForAvailableKeys(data, encryptionOptions, printOptions) {
+        if (printOptions === null || printOptions === void 0 ? void 0 : printOptions.printInput) {
+            this._printInput(data, encryptionOptions);
+        }
+        const commonKeyPath = path_1.default.resolve(__dirname, "../keys");
+        const publicKeys = this._retrievePublicKeys(commonKeyPath);
+        const encryptedData = this.encryptDataForMultipleKeys(data, encryptionOptions, publicKeys);
+        if (printOptions === null || printOptions === void 0 ? void 0 : printOptions.printOutput) {
+            this._printOutput(encryptedData);
+        }
+        return encryptedData;
+    }
+    /**
+     * @description Encrypts data for all passed public keys.
+     * @param data Data to be encrypted.
+     * @param encryptionOptions Encryption options.
+     * @param publicKeys Public keys for encryption.
+     */
+    static encryptDataForMultipleKeys(data, encryptionOptions, publicKeys) {
+        const encodedDataAggregated = [];
+        data = encryptionOptions.useBase64Input ? Util_1.default.base64ToUtf8(data) : data;
+        for (const pk of publicKeys) {
+            let encryptedData;
+            try {
+                encryptedData = this._encryptData(data, pk.key, encryptionOptions);
+            }
+            catch (error) {
+                ErrorHandler_1.default.handleAndThrowError(error, `Encryption failed`);
+            }
+            const encodedData = encryptionOptions.useBase64Output ? Util_1.default.utf8ToBase64(encryptedData) : encryptedData;
+            encodedDataAggregated.push({ root: pk.root, encodedData });
+        }
+        return encodedDataAggregated;
+    }
+    // ========================== Private functions ==========================
+    /**
+     * @description Retrieves the public keys from the file system.
+     * @param keyPath Path to the directory containing the public key.
+     * @returns An array containing public key objects.
+     */
+    static _retrievePublicKeys(keyPath) {
+        const publicKeys = [];
+        try {
+            const publicKey = fs_1.default.readFileSync(path_1.default.resolve(process.cwd(), common_1.PUBLIC_KEY_NAME), "utf8");
+            publicKeys.push({ root: "cwd", key: publicKey });
+        }
+        catch (_a) {
+            // Do nothing
+        }
+        try {
+            const publicKey = fs_1.default.readFileSync(path_1.default.resolve(keyPath, common_1.PUBLIC_KEY_NAME), "utf8");
+            publicKeys.push({ root: "qmate", key: publicKey });
+        }
+        catch (_b) {
+            // Do nothing
+        }
+        if (publicKeys.length < 1) {
+            throw new Error(`${ErrorHandler_1.default.NO_PUBLIC_KEY_ERROR_MESSAGE}.`);
+        }
+        return publicKeys;
+    }
+    /**
+     * @description Encrypts the given data with the provided public key and options.
+     * @param data Data to be encrypted.
+     * @param publicKey Public key for encryption.
+     * @param options Encryption options.
+     * @returns The encrypted data.
+     */
+    static _encryptData(data, publicKey, options) {
+        try {
+            const encryptedDataByKey = crypto_1.default.publicEncrypt({
+                key: Util_1.default.parseKeyByEncoding(publicKey),
+                padding: crypto_1.default.constants.RSA_PKCS1_OAEP_PADDING,
+                oaepHash: "sha256"
+            }, Buffer.from(data));
+            return this._encryptDataWithPassword(encryptedDataByKey.toString("base64"), options);
+        }
+        catch (error) {
+            ErrorHandler_1.default.handleAndThrowError(error);
+        }
+    }
+    /**
+     * @description Encrypts data using AES-256-CBC encryption and PBKDF2 key derivation. The key is derived from the repo URL or a static password.
+     * @param data Data to be encrypted.
+     * @param options Encryption options.
+     * @returns The AES encrypted data.
+     */
+    static _encryptDataWithPassword(data, options) {
+        let key;
+        if (options.includeRepoUrl) {
+            const repoUrl = Util_1.default.getRepoUrl();
+            const repoUrlContractHashed = Util_1.default.unifyRepoUrl(repoUrl);
+            key = crypto_1.default.pbkdf2Sync(repoUrlContractHashed, common_1.SALT, common_1.ITERATIONS, common_1.KEY_LENGTH, common_1.DIGEST);
+        }
+        else {
+            key = crypto_1.default.pbkdf2Sync(common_1.STATIC_PASSWORD, common_1.SALT, common_1.ITERATIONS, common_1.KEY_LENGTH, common_1.DIGEST);
+        }
+        const cipher = crypto_1.default.createCipheriv(common_1.ALGORITHM, key, common_1.IV);
+        let encryptedData = cipher.update(data, "utf-8", "hex");
+        encryptedData += cipher.final("hex");
+        return encryptedData;
+    }
+    /**
+     * @description Prints the input options and data to the console.
+     * @param options Encryption options.
+     * @param data Data to be encrypted.
+     */
+    static _printInput(data, options) {
+        console.log("\n===========INPUT==========================================================");
+        if (options.includeRepoUrl || options.useBase64Output || options.useBase64Input) {
+            console.log("Options:");
+            if (options.includeRepoUrl) {
+                console.log("\x1b[33m - Using repo URL in key derivation.\x1b[0m");
+            }
+            if (options.useBase64Input) {
+                console.log("\x1b[33m - Input data is processed as base64 format.\x1b[0m");
+            }
+            if (options.useBase64Output) {
+                console.log("\x1b[33m - Output data is displayed in base64 format.\x1b[0m");
+            }
+            console.log("");
+        }
+        console.log(`Input Data: ${data}`);
+        console.log("==========================================================================\n");
+    }
+    /**
+     * @description Prints the output data and metadata to the console for multiple pieces of data.
+     * @param encodedDataList An array of encoded data objects containing root and encodedData.
+     */
+    static _printOutput(encodedDataList) {
+        console.log("\n===========OUTPUT=========================================================");
+        console.log(`Processing Info:`);
+        // Iterate through the array and print details for each entry
+        encodedDataList.forEach(({ root, encodedData }) => {
+            const rootMessage = root === "cwd" ? "current working directory" : "qmate module";
+            console.log(`\x1b[33m - Public key is used from ${rootMessage}.\x1b[0m\n`);
+            console.log("Encrypted Data ⬎");
+            console.log(`\x1b[32m${encodedData}\x1b[0m\n`);
+        });
+        console.log("==========================================================================");
+    }
+}
+exports.default = Encrypter;

package/packages/qcrypt/dist/classes/KeyGenerator.d.ts

@@ -0,0 +1,19 @@
+import { KeyGenerationOptions } from "../types/common";
+export default abstract class KeyGenerator {
+    /**
+     * @description Generates a key pair and prints it to the console.
+     * @param options Key generation options.
+     */
+    static generateKeyPair(options: KeyGenerationOptions): void;
+    /**
+     * @description Prints the input options to the console.
+     * @param options Key generation options.
+     */
+    private static _printInput;
+    /**
+     * @description Prints the generated key pair to the console.
+     * @param publicKey The generated public key.
+     * @param privateKey The generated private key.
+     */
+    private static _printOutput;
+}

package/packages/qcrypt/dist/classes/KeyGenerator.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Imports
+const crypto_1 = __importDefault(require("crypto"));
+// Constants
+const common_1 = require("../constants/common");
+class KeyGenerator {
+    // ========================== Public functions ==========================
+    /**
+     * @description Generates a key pair and prints it to the console.
+     * @param options Key generation options.
+     */
+    static generateKeyPair(options) {
+        this._printInput(options);
+        const { publicKey, privateKey } = crypto_1.default.generateKeyPairSync(common_1.KEY_TYPE, { modulusLength: 2048 });
+        const publicKeyExported = publicKey.export({ type: common_1.KEY_EXPORT_TYPE, format: common_1.KEY_EXPORT_FORMAT });
+        const privateKeyExported = privateKey.export({ type: common_1.KEY_EXPORT_TYPE, format: common_1.KEY_EXPORT_FORMAT });
+        const publicKeyFormatted = options.useBase64Encoding ? Buffer.from(publicKeyExported, "utf8").toString("base64") : publicKeyExported;
+        const privateKeyFormatted = options.useBase64Encoding ? Buffer.from(privateKeyExported, "utf8").toString("base64") : privateKeyExported;
+        this._printOutput(publicKeyFormatted, privateKeyFormatted);
+    }
+    // ========================== Private functions ==========================
+    /**
+     * @description Prints the input options to the console.
+     * @param options Key generation options.
+     */
+    static _printInput(options) {
+        if (options.useBase64Encoding) {
+            console.log("\n===========OPTIONS==========================================================");
+            if (options.useBase64Encoding) {
+                console.log("\x1b[33m - Output data is displayed in base64 format.\x1b[0m");
+            }
+            console.log("==========================================================================");
+        }
+    }
+    /**
+     * @description Prints the generated key pair to the console.
+     * @param publicKey The generated public key.
+     * @param privateKey The generated private key.
+     */
+    static _printOutput(publicKey, privateKey) {
+        console.log("\n===========OUTPUT=========================================================");
+        console.log("Public Key ⬎");
+        console.log(`\x1b[32m${publicKey}\x1b[0m\n`);
+        console.log("Private Key ⬎");
+        console.log(`\x1b[33m${privateKey}\x1b[0m`);
+        console.log("==========================================================================");
+    }
+}
+exports.default = KeyGenerator;

package/packages/qcrypt/dist/classes/helper/ErrorHandler.d.ts

@@ -0,0 +1,11 @@
+import { DecryptionOptions } from "../../types/common";
+export default abstract class ErrorHandler {
+    static UNKNOWN_ERROR_MESSAGE: string;
+    static NO_PUBLIC_KEY_ERROR_MESSAGE: string;
+    static NO_PRIVATE_KEY_ERROR_MESSAGE: string;
+    static INVALID_PRIVATE_KEY_ERROR_MESSAGE: string;
+    static DECRYPTION_ERROR_MESSAGE: string;
+    static handleAndThrowError(error: Error | unknown, customMessage?: string): never;
+    static handleDecryptDataWithPasswordError(error: Error, options: DecryptionOptions): string;
+    static handleDecryptDataWithPrivateKeyError(error: Error): string;
+}

package/packages/qcrypt/dist/classes/helper/ErrorHandler.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ErrorHandler {
+    // ========================== Public functions ==========================
+    // Common error handlers
+    static handleAndThrowError(error, customMessage) {
+        if (error instanceof Error) {
+            if (customMessage) {
+                throw new Error(`${customMessage}: ${error.message}`);
+            }
+            else {
+                throw new Error(error.message);
+            }
+        }
+        else {
+            throw new Error(ErrorHandler.UNKNOWN_ERROR_MESSAGE);
+        }
+    }
+    // Decryption error handlers
+    static handleDecryptDataWithPasswordError(error, options) {
+        let errorMessage = error.message;
+        switch (error.message) {
+            case "error:1C800064:Provider routines::bad decrypt":
+                errorMessage = "The data is not encrypted with the correct key.";
+                if (options.includeRepoUrl) {
+                    errorMessage += " Make sure the data is encrypted from the correct repository.";
+                }
+                break;
+            case "error:1C80006B:Provider routines::wrong final block length":
+                errorMessage = "The data is not encrypted with the correct key or the data is corrupted.";
+                if (options.useBase64Input) {
+                    errorMessage += " Make sure the input data is valid base64 format.";
+                }
+                if (options.includeRepoUrl) {
+                    errorMessage += " Make sure the data is encrypted from the correct repository.";
+                }
+                break;
+            default:
+                errorMessage = `${this.UNKNOWN_ERROR_MESSAGE}: ${error.message}`;
+                break;
+        }
+        return errorMessage;
+    }
+    static handleDecryptDataWithPrivateKeyError(error) {
+        let errorMessage = error.message;
+        switch (error.message) {
+            case "error:1E08010C:DECODER routines::unsupported":
+                errorMessage = `${this.INVALID_PRIVATE_KEY_ERROR_MESSAGE}.`;
+                break;
+            case "Invalid base64 format. Please provide a valid base64 encoded string.":
+                errorMessage = `${this.INVALID_PRIVATE_KEY_ERROR_MESSAGE}.`;
+                break;
+            default:
+                errorMessage = `${this.UNKNOWN_ERROR_MESSAGE}: ${error.message}`;
+                break;
+        }
+        return errorMessage;
+    }
+}
+// ========================== Constants =================================
+// Common error messages
+ErrorHandler.UNKNOWN_ERROR_MESSAGE = "Unknown error occurred";
+// Encryption error messages
+ErrorHandler.NO_PUBLIC_KEY_ERROR_MESSAGE = "Encryption failed: No public key found";
+// Decryption error messages
+ErrorHandler.NO_PRIVATE_KEY_ERROR_MESSAGE = "Decryption failed: No private key found";
+ErrorHandler.INVALID_PRIVATE_KEY_ERROR_MESSAGE = "Invalid private key";
+ErrorHandler.DECRYPTION_ERROR_MESSAGE = "Decryption failed: None of the given data values could be decrypted using the given private key";
+exports.default = ErrorHandler;

package/packages/qcrypt/dist/classes/helper/Util.d.ts

@@ -0,0 +1,69 @@
+export default abstract class Util {
+    /**
+     * @description Converts the given string to base64.
+     * @param string The string to be converted.
+     * @returns The base64 encoded string.
+     */
+    static base64ToUtf8(string: string): string;
+    /**
+     * @description Converts the given string to base64.
+     * @param string The string to be converted.
+     * @returns The base64 encoded string.
+     */
+    static utf8ToBase64(string: string): string;
+    /**
+     * @description Checks if the given string is base64 encoded.
+     * @param string The string to be checked.
+     * @returns True if the string is base64 encoded, false otherwise.
+     */
+    static isBase64(string: string): boolean;
+    /**
+     * @description Parses the key by encoding.
+     * @param key The key to be parsed.
+     * @returns The parsed key.
+     */
+    static parseKeyByEncoding(key: string): string;
+    /**
+     * @description Normalizes the key by removing spaces and new lines.
+     * @param key The key to be normalized.
+     * @returns The normalized key.
+     */
+    static normalizeKey(key: string): string;
+    /**
+     * @description Retrieves the repository URL from the git configuration.
+     * @returns The repository URL.
+     */
+    static getRepoUrl(): string;
+    /**
+     * @description Unifies the repository URL into a consistent hash format.
+     * @param url The repository URL.
+     * @returns The hashed URL.
+     */
+    static unifyRepoUrl(url: string): string;
+    /**
+     * @description Unifies the HTTP repository URL into a consistent hash format.
+     * @param url The repository URL.
+     * @returns The hashed URL.
+     */
+    static unifyHTTPUrl(url: string): string;
+    /**
+     * @description Unifies the SSH repository URL into a consistent hash format.
+     * @param url The repository URL.
+     * @returns The hashed URL.
+     */
+    static unifySSHUrl(url: string): string;
+    /**
+     * @description Hashes the host, account, and repository into a consistent format.
+     * @param host The repository host.
+     * @param account The repository account.
+     * @param repo The repository name.
+     * @returns The hashed host, account, and repository.
+     */
+    static hashHostAccountAndRepo(host: string, account: string, repo: string): string;
+    /**
+     * @description Converts the given string to an array of strings if not yet an array.
+     * @param data The string or array of strings.
+     * @returns The array of strings.
+     */
+    static convertStringToArray(data: string | Array<string>): Array<string>;
+}

package/packages/qcrypt/dist/classes/helper/Util.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Imports
+const child_process_1 = __importDefault(require("child_process"));
+const crypto_1 = __importDefault(require("crypto"));
+class Util {
+    /**
+     * @description Converts the given string to base64.
+     * @param string The string to be converted.
+     * @returns The base64 encoded string.
+     */
+    static base64ToUtf8(string) {
+        if (!this.isBase64(string)) {
+            throw new Error("Invalid base64 format. Please provide a valid base64 encoded string.");
+        }
+        return Buffer.from(string, "base64").toString("utf-8");
+    }
+    /**
+     * @description Converts the given string to base64.
+     * @param string The string to be converted.
+     * @returns The base64 encoded string.
+     */
+    static utf8ToBase64(string) {
+        return Buffer.from(string, "utf-8").toString("base64");
+    }
+    /**
+     * @description Checks if the given string is base64 encoded.
+     * @param string The string to be checked.
+     * @returns True if the string is base64 encoded, false otherwise.
+     */
+    static isBase64(string) {
+        const base64Regex = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+        return base64Regex.test(string);
+    }
+    /**
+     * @description Parses the key by encoding.
+     * @param key The key to be parsed.
+     * @returns The parsed key.
+     */
+    static parseKeyByEncoding(key) {
+        const utf8Regex = /-*(BEGIN|END)\s\w*\s(PUBLIC|PRIVATE)\sKEY-*/;
+        return utf8Regex.test(key) ? key : this.base64ToUtf8(key);
+    }
+    /**
+     * @description Normalizes the key by removing spaces and new lines.
+     * @param key The key to be normalized.
+     * @returns The normalized key.
+     */
+    static normalizeKey(key) {
+        return key.replace(/\\n/gm, "\n").replace(/\\s/gm, " ");
+    }
+    /**
+     * @description Retrieves the repository URL from the git configuration.
+     * @returns The repository URL.
+     */
+    static getRepoUrl() {
+        try {
+            return child_process_1.default.execSync("git config --get remote.origin.url").toString().trim();
+        }
+        catch (_a) {
+            throw new Error("Please execute from a valid git repository.");
+        }
+    }
+    /**
+     * @description Unifies the repository URL into a consistent hash format.
+     * @param url The repository URL.
+     * @returns The hashed URL.
+     */
+    static unifyRepoUrl(url) {
+        const httpsRegex = /https?:\/\/.+/;
+        const sshRegex = /git@.*:.+/;
+        if (httpsRegex.test(url)) {
+            return this.unifyHTTPUrl(url);
+        }
+        else if (sshRegex.test(url)) {
+            return this.unifySSHUrl(url);
+        }
+        else {
+            throw new Error("Repo URL is not valid.");
+        }
+    }
+    /**
+     * @description Unifies the HTTP repository URL into a consistent hash format.
+     * @param url The repository URL.
+     * @returns The hashed URL.
+     */
+    static unifyHTTPUrl(url) {
+        const [host, account, repo] = url.replace(/https?:\/\//, "").split("/");
+        return this.hashHostAccountAndRepo(host, account, repo.replace(/\.git$/, ""));
+    }
+    /**
+     * @description Unifies the SSH repository URL into a consistent hash format.
+     * @param url The repository URL.
+     * @returns The hashed URL.
+     */
+    static unifySSHUrl(url) {
+        const [hostAccount, repo] = url.replace("git@", "").split(":");
+        const [host, account] = hostAccount.split("/");
+        return this.hashHostAccountAndRepo(host, account, repo.replace(/\.git$/, ""));
+    }
+    /**
+     * @description Hashes the host, account, and repository into a consistent format.
+     * @param host The repository host.
+     * @param account The repository account.
+     * @param repo The repository name.
+     * @returns The hashed host, account, and repository.
+     */
+    static hashHostAccountAndRepo(host, account, repo) {
+        return crypto_1.default.createHash("sha256").update(`${host}${account}${repo}`).digest("hex");
+    }
+    /**
+     * @description Converts the given string to an array of strings if not yet an array.
+     * @param data The string or array of strings.
+     * @returns The array of strings.
+     */
+    static convertStringToArray(data) {
+        if (typeof data === "string") {
+            data = [data];
+        }
+        return data;
+    }
+}
+exports.default = Util;

package/packages/qcrypt/dist/constants/common.d.ts

@@ -0,0 +1,12 @@
+export declare const PUBLIC_KEY_NAME = "public.key";
+export declare const PRIVATE_KEY_NAME = "private.key";
+export declare const STATIC_PASSWORD = "QMATE_STATIC";
+export declare const ALGORITHM = "aes-256-cbc";
+export declare const DIGEST = "sha512";
+export declare const SALT = "72hdh393987f0hdc";
+export declare const IV = "203efccd80e94d9f";
+export declare const ITERATIONS = 100000;
+export declare const KEY_LENGTH = 32;
+export declare const KEY_TYPE = "rsa";
+export declare const KEY_EXPORT_TYPE = "pkcs1";
+export declare const KEY_EXPORT_FORMAT = "pem";

package/packages/qcrypt/dist/constants/common.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEY_EXPORT_FORMAT = exports.KEY_EXPORT_TYPE = exports.KEY_TYPE = exports.KEY_LENGTH = exports.ITERATIONS = exports.IV = exports.SALT = exports.DIGEST = exports.ALGORITHM = exports.STATIC_PASSWORD = exports.PRIVATE_KEY_NAME = exports.PUBLIC_KEY_NAME = void 0;
+exports.PUBLIC_KEY_NAME = "public.key";
+exports.PRIVATE_KEY_NAME = "private.key";
+exports.STATIC_PASSWORD = "QMATE_STATIC";
+exports.ALGORITHM = "aes-256-cbc";
+exports.DIGEST = "sha512";
+exports.SALT = "72hdh393987f0hdc";
+exports.IV = "203efccd80e94d9f";
+exports.ITERATIONS = 100000;
+exports.KEY_LENGTH = 32;
+exports.KEY_TYPE = "rsa";
+exports.KEY_EXPORT_TYPE = "pkcs1";
+exports.KEY_EXPORT_FORMAT = "pem";

package/packages/qcrypt/dist/index.d.ts

@@ -0,0 +1,4 @@
+import Encrypter from "./classes/Encrypter";
+import Decrypter from "./classes/Decrypter";
+import KeyGenerator from "./classes/KeyGenerator";
+export { Decrypter, Encrypter, KeyGenerator };

package/packages/qcrypt/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyGenerator = exports.Encrypter = exports.Decrypter = void 0;
+const Encrypter_1 = __importDefault(require("./classes/Encrypter"));
+exports.Encrypter = Encrypter_1.default;
+const Decrypter_1 = __importDefault(require("./classes/Decrypter"));
+exports.Decrypter = Decrypter_1.default;
+const KeyGenerator_1 = __importDefault(require("./classes/KeyGenerator"));
+exports.KeyGenerator = KeyGenerator_1.default;

package/packages/qcrypt/dist/keys/public.key

@@ -0,0 +1,8 @@
+-----BEGIN RSA PUBLIC KEY-----
+MIIBCgKCAQEA4IRW72V6EgSF4ukoToruv7M5tOVw+SyAxnicAAQ6ByZZkXeDgrIC
+ePxceWVugIDazNC0fOCKARFd06OThhRfQ9UftIb2Aju/00AygY3jsO/xTmwTLwcK
+mVYbFeSUc4NKYyqvB2vfJeC0Y6zSzlMmWe9NL8vTpHsrLT9jBaeG+8Yc6Uw/j+qH
+swxdu9lyzTgcIiq3oYuDQIQr8jDclQ8oLVo11xTyvcmOpyrtSan7d953sxgsSKr6
++fGkLXrfzBswTGxYyQkqVdYiRGI0HFLcYDk6Qd77q0GQjF3zP0v3o1CA943I75i1
+5RMPI29WGC+QIHm6XFVcq4ie/D6Ixx2/IQIDAQAB
+-----END RSA PUBLIC KEY-----

package/packages/qcrypt/dist/types/common.d.ts

@@ -0,0 +1,27 @@
+export interface EncryptionOptions {
+    includeRepoUrl: boolean;
+    useBase64Output: boolean;
+    useBase64Input: boolean;
+}
+export interface DecryptionOptions {
+    includeRepoUrl: boolean;
+    useBase64Output: boolean;
+    useBase64Input: boolean;
+}
+export interface KeyGenerationOptions {
+    useBase64Encoding: boolean;
+}
+export interface PrintOptions {
+    printInput: boolean;
+    printOutput: boolean;
+}
+export interface PublicKey {
+    root: KeyRoot;
+    key: string;
+}
+export interface EncodedData {
+    root: KeyRoot;
+    encodedData: string;
+}
+export type KeyRoot = "cwd" | "qmate";
+export type SecureData = string | Array<string>;

package/packages/qcrypt/dist/types/common.js

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

package/packages/qcrypt/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "qcrypt",
+  "version": "1.0.2",
+  "description": "Local version of qcrypt package",
+  "author": "I503232",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts"
+}