http-request-manager 0.0.2 → 0.0.20

package/esm2022/lib/services/utils/encryption/asymmetrical-encryption.service.mjs

@@ -0,0 +1,186 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, EMPTY, from } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class AsymmetricalEncryptionService {
+    constructor() { }
+    generateKeyPair(modulusLength = 2048) {
+        // modulusLength - 1024, 2048, 4096
+        // hash - SHA-256
+        return from(crypto.subtle.generateKey({
+            name: "RSA-OAEP",
+            modulusLength,
+            publicExponent: new Uint8Array([1, 0, 1]),
+            hash: { name: "SHA-256" }
+        }, true, // Extractable keys
+        ["encrypt", "decrypt"]));
+    }
+    encryptData(publicKey, data) {
+        const encodedData = new TextEncoder().encode(data);
+        return from(crypto.subtle.encrypt({
+            name: "RSA-OAEP"
+        }, publicKey, encodedData)).pipe(map(enc => this.arrayBufferToBase64(enc)));
+    }
+    decryptData(privateKey, encryptedData) {
+        const encStr = this.base64ToArrayBuffer(encryptedData);
+        return from(crypto.subtle.decrypt({
+            name: "RSA-OAEP"
+        }, privateKey, encStr).then(decryptedData => {
+            return new TextDecoder().decode(decryptedData);
+        }));
+    }
+    pemToArrayBuffer(pem) {
+        const b64 = pem.replace(/(-----BEGIN (RSA )?(PRIVATE|PUBLIC) KEY-----|-----END (RSA )?(PRIVATE|PUBLIC) KEY-----|\n)/g, '');
+        const binaryString = atob(b64);
+        const len = binaryString.length;
+        const buffer = new ArrayBuffer(len);
+        const view = new Uint8Array(buffer);
+        for (let i = 0; i < len; i++) {
+            view[i] = binaryString.charCodeAt(i);
+        }
+        return buffer;
+    }
+    base64ToArrayBuffer(base64) {
+        const binaryString = atob(base64);
+        const len = binaryString.length;
+        const buffer = new ArrayBuffer(len);
+        const view = new Uint8Array(buffer);
+        for (let i = 0; i < len; i++) {
+            view[i] = binaryString.charCodeAt(i);
+        }
+        return buffer;
+    }
+    arrayBufferToBase64(buffer) {
+        let binary = '';
+        const bytes = new Uint8Array(buffer);
+        const len = bytes.byteLength;
+        for (let i = 0; i < len; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return window.btoa(binary);
+    }
+    base64ToPEM(base64Key, publicKey = true) {
+        const keyType = (publicKey) ? 'PUBLIC' : 'PRIVATE';
+        const header = `-----BEGIN ${keyType} KEY-----\n`;
+        const footer = `\n-----END ${keyType} KEY-----`;
+        const keyBody = base64Key.match(/.{1,64}/g)?.join("\n") || "";
+        return header + keyBody + footer;
+    }
+    pemToCryptoKey(pem, algorithm, extractable, keyUsages, format = "pkcs8" //"raw" | "pkcs8" | "spki"
+    ) {
+        const buffer = this.pemToArrayBuffer(pem);
+        console.log('buffer found ', buffer);
+        return from(crypto.subtle.importKey(format, buffer, algorithm, extractable, keyUsages));
+    }
+    // TESTING
+    testGenerateKeys() {
+        const testSequence = new BehaviorSubject("");
+        const testSequence$ = testSequence.asObservable();
+        testSequence.next("Test Generating Keys");
+        // GENERATE KEYS
+        this.generateKeyPair().subscribe((data) => {
+            console.log("GEN-GENERATED KEYS: ", data);
+            crypto.subtle.exportKey('spki', data.publicKey)
+                .then(key => {
+                const publicKeyBase64 = this.arrayBufferToBase64(key);
+                console.log("GEN-EXPORT PUBLIC KEY: ", this.base64ToPEM(publicKeyBase64, true));
+            });
+            crypto.subtle.exportKey('pkcs8', data.privateKey)
+                .then(key => {
+                const privateKeyBase64 = this.arrayBufferToBase64(key);
+                console.log("GEN-EXPORT PRIVATE KEY: ", this.base64ToPEM(privateKeyBase64, false));
+            });
+            // TEST WITH GENERATED KEYS
+            this.encryptData(data.publicKey, "Sample Data here - Mike Bonifacio")
+                .subscribe((enc) => {
+                console.log("GEN-ENCRYPT==>: ", enc);
+                this.decryptData(data.privateKey, enc).subscribe((dec) => {
+                    testSequence.next('Test Passed');
+                    testSequence.complete();
+                });
+            });
+        });
+        return testSequence$;
+    }
+    testDecryptionWithKeys() {
+        const testSequence = new BehaviorSubject("");
+        const testSequence$ = testSequence.asObservable();
+        testSequence.next("Test Generating Keys");
+        const privateKey = `-----BEGIN PRIVATE KEY-----
+    MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDKVBkCWNb9eHVF
+    twAA5mdAyvXFix3WavdrsoYRkvtCl8ogDBQf8f6N0bRkDF1zcVHRrNAEyozXDtuD
+    kFgSiivBFREI7fiS3sOvduq6FaGXzX0IY6oaVMu8oOPgDvC0yvoohR+0Qxq2d6lP
+    SPyHeKQaxP4KxzCJJzB1XAcbd2eFzUUDv25mNlwdVkmW8FI/sAxnJLgPTW78dzfX
+    Ddfk+nxdIqxVKSLATnL0kMN7aGJx24UozioAIpzvvvF5/+7HTd1gi6NeCqrAYr3g
+    iP364AE26CFwFvHnafO9uNQhlQ+uiNnOoInXByfFGVP+RidSpfLzaxDjs6RDwpol
+    h098btONAgMBAAECggEAAVhHM2OD5IkUtuowwcKNaCTKGmrClRE3gMuzJeBsSJEy
+    uAReUFILZylcnhegDytSti2vDA9T7xqtO6CU0p3V8LpU89JMOPRb/deirI4UXSpx
+    xbNyjirOO6bnrNlOWfKexdQQsikYPzF2iM1Scpr1u9ZDCHZOl1ZYSrkve5My4coP
+    3Gx6tTBqL0jQBfcpf4ES8BH3JSawR/MgqzDS74+bI2VH+kvuPAC1L4fBgaV3VUv0
+    nFzim5A3s5VaXPgJbEIghP9BkYGFkeT9ma3nliEZWc96AzsmowFn1ayCvrNVPo9R
+    ECD2NnttBiCJZt3H93sR9+OTeA8Bls+aZGlKd5mLAQKBgQDpf8nIYUm/Zmls7/lQ
+    QBUSGHEYrbjNsEejQsPgNDtg2EVSxdUkvTn7Wb+HExTk09Z5bNvhaO2532/FH9y8
+    ahSXafiMXpfR2olwXdOB9yXXl4F5C0LGnmzGim4OSeWzAX0JCL470KaS0QN3EmoG
+    9F0YCfMnZXNTweSSx4xvlO6ggQKBgQDd01uIolm7z1DIWCwNERAXP2GDwcvxyzYK
+    YqJfKDeHt2t6yIzZMMotnPDy+OlcdGspIIHkB5a+SZN5Nt7DUKg/MnyOZ3KbVq41
+    k7dR4Ka3LRnGkesy7lSr7ef1rfquyR75OXJQcPWvkFcLu0TMiQhvptatZ8VN+F4n
+    fDQELRotDQKBgQCgN+AUT7VT0QjcCBnRV/ddUEoiPenFsYSmYMSYzh5ESIHg1wB2
+    0iS79Iw4Of6nOTg8X1bM57vfQ5Kk90T2P+/bKYqzfqC8DTErWiYsUpKzyTC9Bt4N
+    /Vz0Kr5zrX8ggg/yp/4oevYhXav8AzWfigNq4EDpMnKc8TlPAf+5/L50gQKBgQC2
+    mLPhPhr1gUszD3l7bA89w7uGlLFHoQoj9FtKTzWervp3QLzIT+QtNeIVb5XQuDg5
+    y3uAdEq+6pvNjMBEMJG+K9Xh9v+dJPYUPjsJ2A4D/MkZ7qWX8B2cxSJK1uLim8W2
+    S3ZxBvsGgJ9WldmlMCvUlJZkeWYtr4P5psC+q02/xQKBgQCDII/jcV2+lRM2iNTe
+    vBijZSaNMEWOK/Y+/HFK8GYKXnB+xNWhrm8rKgWGzpDJAUPMh9Tt+leW9LKEBuzF
+    Y1bGblmGm1zsPWpIx05Fdtv9eOJmFnXbGzIsYyhadZnPcQOWhqxtpVxSuul0Jc7Q
+    XNq4qPaPXhbQAshgtyBt75DMkw==
+    -----END PRIVATE KEY-----`;
+        const pubKey = `-----BEGIN PUBLIC KEY-----
+    MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAylQZAljW/Xh1RbcAAOZn
+    QMr1xYsd1mr3a7KGEZL7QpfKIAwUH/H+jdG0ZAxdc3FR0azQBMqM1w7bg5BYEoor
+    wRURCO34kt7Dr3bquhWhl819CGOqGlTLvKDj4A7wtMr6KIUftEMatnepT0j8h3ik
+    GsT+CscwiScwdVwHG3dnhc1FA79uZjZcHVZJlvBSP7AMZyS4D01u/Hc31w3X5Pp8
+    XSKsVSkiwE5y9JDDe2hicduFKM4qACKc777xef/ux03dYIujXgqqwGK94Ij9+uAB
+    NughcBbx52nzvbjUIZUProjZzqCJ1wcnxRlT/kYnUqXy82sQ47OkQ8KaJYdPfG7T
+    jQIDAQAB
+    -----END PUBLIC KEY-----`;
+        const algorithm = {
+            name: "RSA-OAEP",
+            modulusLength: 2048,
+            publicExponent: new Uint8Array([1, 0, 1]),
+            hash: "SHA-256"
+        };
+        // ENCRYPT
+        this.pemToCryptoKey(pubKey, algorithm, true, ["encrypt"], "spki").subscribe((keyPublic) => {
+            // console.log("PUBLIC KEY: ", keyPublic)
+            this.encryptData(keyPublic, "Sample Data here - Mike Bonifacio")
+                .subscribe((str) => {
+                console.log("ENCRYPTED STRING: ", str);
+                testSequence.next('encrypted string success');
+            });
+        });
+        const enc = "r7UOuEGBZ6jbVTOIBuv9jFOEtRiedmS27hfW40k7XKCTsQ5VhWup0qu2BA2ANZaGKii/uehJ/RSPiyfGbJ6leJrat0mA1hPqH/XodaBzLMDigvdYM1NSXFZMDa40OpLUIXbPlAvybjcGu7Bal+LMA8htHrFu/OmM/fHI66xOzzpuXSYx0OkWjtY81rUQ1FFkvrkx2jGFPZ0p+Nw/v3Q4cJnet6V63vCueFlD749VMcVXo7pvz4AIPpB+IOy3kbxaYTPakLVioJERU6GFMXWkECuRvohhS9CETcORZtRVRkvhcHk3lxgIhfqojUKYgD6K5dDELDPsWIS+iTG1XIQIlg==";
+        // DECRYPTION
+        this.pemToCryptoKey(privateKey, algorithm, false, ["decrypt"], "pkcs8").subscribe((key) => {
+            // console.log("DECRYPT ===", key)
+            this.decryptData(key, enc)
+                .pipe(catchError(err => {
+                console.log("ERROR: ", err);
+                return EMPTY;
+            })).subscribe((str) => {
+                console.log("DECRYPTED STRING: ", str);
+                testSequence.next('decrypted string success');
+            });
+        });
+        return testSequence$;
+    }
+    ;
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AsymmetricalEncryptionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AsymmetricalEncryptionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AsymmetricalEncryptionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"asymmetrical-encryption.service.js","sourceRoot":"","sources":["../../../../../../../projects/http-request-manager/src/lib/services/utils/encryption/asymmetrical-encryption.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { BehaviorSubject, EMPTY, Observable, from, of } from 'rxjs';\nimport { map, catchError } from 'rxjs/operators';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class AsymmetricalEncryptionService {\n\n  constructor() {}\n\n  generateKeyPair(modulusLength = 2048): Observable<CryptoKeyPair> {\n  \n    // modulusLength - 1024, 2048, 4096\n    // hash - SHA-256\n\n   return from(crypto.subtle.generateKey(\n      {\n        name: \"RSA-OAEP\",\n        modulusLength,\n        publicExponent: new Uint8Array([1, 0, 1]), // 65537\n        hash: { name: \"SHA-256\" }\n      },\n      true, // Extractable keys\n      [\"encrypt\", \"decrypt\"]\n    ))\n\n  }\n\n  encryptData(publicKey: CryptoKey, data: string) {\n\n    const encodedData = new TextEncoder().encode(data)\n\n    return from(crypto.subtle.encrypt(\n      {\n        name: \"RSA-OAEP\"\n      },\n      publicKey,\n      encodedData\n    )).pipe(\n      map(enc => this.arrayBufferToBase64(enc))\n    )\n\n  }\n\n  decryptData(privateKey: CryptoKey, encryptedData: string) {\n\n    const encStr = this.base64ToArrayBuffer(encryptedData)\n\n    return from(crypto.subtle.decrypt(\n      {\n        name: \"RSA-OAEP\"\n      },\n      privateKey,\n      encStr\n    ).then(decryptedData => {\n      return new TextDecoder().decode(decryptedData)\n    }))\n\n  }\n\n  pemToArrayBuffer(pem: string): ArrayBuffer {\n\n    const b64 = pem.replace(/(-----BEGIN (RSA )?(PRIVATE|PUBLIC) KEY-----|-----END (RSA )?(PRIVATE|PUBLIC) KEY-----|\\n)/g, '')\n    const binaryString = atob(b64)\n    const len = binaryString.length\n    const buffer = new ArrayBuffer(len)\n    const view = new Uint8Array(buffer)\n\n    for (let i = 0; i < len; i++) {\n      view[i] = binaryString.charCodeAt(i)\n    }\n\n    return buffer\n\n  }\n\n  base64ToArrayBuffer(base64: string): ArrayBuffer {\n    \n    const binaryString = atob(base64);\n    const len = binaryString.length;\n    const buffer = new ArrayBuffer(len);\n    const view = new Uint8Array(buffer);\n\n    for (let i = 0; i < len; i++) {\n        view[i] = binaryString.charCodeAt(i);\n    }\n\n    return buffer;\n  }\n\n  arrayBufferToBase64(buffer: ArrayBuffer): string {\n\n    let binary = '';\n    const bytes = new Uint8Array(buffer);\n    const len = bytes.byteLength;\n\n    for (let i = 0; i < len; i++) {\n      binary += String.fromCharCode(bytes[i]);\n    }\n\n    return window.btoa(binary)\n\n  }\n\n  base64ToPEM(base64Key: string, publicKey = true) {\n\n    const keyType = (publicKey) ? 'PUBLIC' : 'PRIVATE'\n\n    const header = `-----BEGIN ${keyType} KEY-----\\n`\n    const footer = `\\n-----END ${keyType} KEY-----`\n\n    const keyBody = base64Key.match(/.{1,64}/g)?.join(\"\\n\") || \"\"\n\n    return header + keyBody + footer\n\n  }\n\n  pemToCryptoKey(\n    pem: string, \n    algorithm: RsaHashedKeyGenParams, \n    extractable: boolean, \n    keyUsages: KeyUsage[],\n    format: any = \"pkcs8\" //\"raw\" | \"pkcs8\" | \"spki\"\n    ) {\n    \n    const buffer = this.pemToArrayBuffer(pem);\n\n    console.log('buffer found ', buffer);\n    \n    return from(crypto.subtle.importKey(\n      format,\n      buffer,\n      algorithm,\n      extractable,\n      keyUsages\n    ))\n\n  }\n  \n  // TESTING\n\n  testGenerateKeys(): Observable<string> {\n    const testSequence: BehaviorSubject<string> = new BehaviorSubject<string>(\"\");\n    const testSequence$: Observable<string> = testSequence.asObservable();\n    testSequence.next(\"Test Generating Keys\");\n\n    // GENERATE KEYS\n    this.generateKeyPair().subscribe((data) => {\n\n      console.log(\"GEN-GENERATED KEYS: \", data)\n\n      crypto.subtle.exportKey('spki', data.publicKey)\n      .then(key => {\n        const publicKeyBase64 = this.arrayBufferToBase64(key);\n        console.log(\"GEN-EXPORT PUBLIC KEY: \", this.base64ToPEM(publicKeyBase64, true));\n      })\n\n      crypto.subtle.exportKey('pkcs8', data.privateKey)\n      .then(key => {\n        const privateKeyBase64 = this.arrayBufferToBase64(key);\n        console.log(\"GEN-EXPORT PRIVATE KEY: \", this.base64ToPEM(privateKeyBase64, false));\n      });\n\n      // TEST WITH GENERATED KEYS\n      this.encryptData(data.publicKey, \"Sample Data here - Mike Bonifacio\")\n          .subscribe((enc) => {\n\n            console.log(\"GEN-ENCRYPT==>: \", enc)\n\n            this.decryptData(data.privateKey, enc).subscribe((dec) => {\n              testSequence.next('Test Passed');\n              testSequence.complete();\n            })\n\n          })\n\n    })\n    return testSequence$;\n\n  }\n\n  testDecryptionWithKeys(): Observable<string> {\n    const testSequence: BehaviorSubject<string> = new BehaviorSubject<string>(\"\");\n    const testSequence$: Observable<string> = testSequence.asObservable();\n    testSequence.next(\"Test Generating Keys\");\n\n    const privateKey = `-----BEGIN PRIVATE KEY-----\n    MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQDKVBkCWNb9eHVF\n    twAA5mdAyvXFix3WavdrsoYRkvtCl8ogDBQf8f6N0bRkDF1zcVHRrNAEyozXDtuD\n    kFgSiivBFREI7fiS3sOvduq6FaGXzX0IY6oaVMu8oOPgDvC0yvoohR+0Qxq2d6lP\n    SPyHeKQaxP4KxzCJJzB1XAcbd2eFzUUDv25mNlwdVkmW8FI/sAxnJLgPTW78dzfX\n    Ddfk+nxdIqxVKSLATnL0kMN7aGJx24UozioAIpzvvvF5/+7HTd1gi6NeCqrAYr3g\n    iP364AE26CFwFvHnafO9uNQhlQ+uiNnOoInXByfFGVP+RidSpfLzaxDjs6RDwpol\n    h098btONAgMBAAECggEAAVhHM2OD5IkUtuowwcKNaCTKGmrClRE3gMuzJeBsSJEy\n    uAReUFILZylcnhegDytSti2vDA9T7xqtO6CU0p3V8LpU89JMOPRb/deirI4UXSpx\n    xbNyjirOO6bnrNlOWfKexdQQsikYPzF2iM1Scpr1u9ZDCHZOl1ZYSrkve5My4coP\n    3Gx6tTBqL0jQBfcpf4ES8BH3JSawR/MgqzDS74+bI2VH+kvuPAC1L4fBgaV3VUv0\n    nFzim5A3s5VaXPgJbEIghP9BkYGFkeT9ma3nliEZWc96AzsmowFn1ayCvrNVPo9R\n    ECD2NnttBiCJZt3H93sR9+OTeA8Bls+aZGlKd5mLAQKBgQDpf8nIYUm/Zmls7/lQ\n    QBUSGHEYrbjNsEejQsPgNDtg2EVSxdUkvTn7Wb+HExTk09Z5bNvhaO2532/FH9y8\n    ahSXafiMXpfR2olwXdOB9yXXl4F5C0LGnmzGim4OSeWzAX0JCL470KaS0QN3EmoG\n    9F0YCfMnZXNTweSSx4xvlO6ggQKBgQDd01uIolm7z1DIWCwNERAXP2GDwcvxyzYK\n    YqJfKDeHt2t6yIzZMMotnPDy+OlcdGspIIHkB5a+SZN5Nt7DUKg/MnyOZ3KbVq41\n    k7dR4Ka3LRnGkesy7lSr7ef1rfquyR75OXJQcPWvkFcLu0TMiQhvptatZ8VN+F4n\n    fDQELRotDQKBgQCgN+AUT7VT0QjcCBnRV/ddUEoiPenFsYSmYMSYzh5ESIHg1wB2\n    0iS79Iw4Of6nOTg8X1bM57vfQ5Kk90T2P+/bKYqzfqC8DTErWiYsUpKzyTC9Bt4N\n    /Vz0Kr5zrX8ggg/yp/4oevYhXav8AzWfigNq4EDpMnKc8TlPAf+5/L50gQKBgQC2\n    mLPhPhr1gUszD3l7bA89w7uGlLFHoQoj9FtKTzWervp3QLzIT+QtNeIVb5XQuDg5\n    y3uAdEq+6pvNjMBEMJG+K9Xh9v+dJPYUPjsJ2A4D/MkZ7qWX8B2cxSJK1uLim8W2\n    S3ZxBvsGgJ9WldmlMCvUlJZkeWYtr4P5psC+q02/xQKBgQCDII/jcV2+lRM2iNTe\n    vBijZSaNMEWOK/Y+/HFK8GYKXnB+xNWhrm8rKgWGzpDJAUPMh9Tt+leW9LKEBuzF\n    Y1bGblmGm1zsPWpIx05Fdtv9eOJmFnXbGzIsYyhadZnPcQOWhqxtpVxSuul0Jc7Q\n    XNq4qPaPXhbQAshgtyBt75DMkw==\n    -----END PRIVATE KEY-----`\n    \n        const pubKey = `-----BEGIN PUBLIC KEY-----\n    MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAylQZAljW/Xh1RbcAAOZn\n    QMr1xYsd1mr3a7KGEZL7QpfKIAwUH/H+jdG0ZAxdc3FR0azQBMqM1w7bg5BYEoor\n    wRURCO34kt7Dr3bquhWhl819CGOqGlTLvKDj4A7wtMr6KIUftEMatnepT0j8h3ik\n    GsT+CscwiScwdVwHG3dnhc1FA79uZjZcHVZJlvBSP7AMZyS4D01u/Hc31w3X5Pp8\n    XSKsVSkiwE5y9JDDe2hicduFKM4qACKc777xef/ux03dYIujXgqqwGK94Ij9+uAB\n    NughcBbx52nzvbjUIZUProjZzqCJ1wcnxRlT/kYnUqXy82sQ47OkQ8KaJYdPfG7T\n    jQIDAQAB\n    -----END PUBLIC KEY-----`\n\n    const algorithm: RsaHashedKeyGenParams = {\n      name: \"RSA-OAEP\",\n      modulusLength: 2048,\n      publicExponent: new Uint8Array([1, 0, 1]),\n      hash: \"SHA-256\"\n    };\n\n    // ENCRYPT\n    this.pemToCryptoKey(\n      pubKey,\n      algorithm,\n      true,\n      [\"encrypt\"],\n      \"spki\"\n    ).subscribe((keyPublic) => {\n\n      // console.log(\"PUBLIC KEY: \", keyPublic)\n\n      this.encryptData(keyPublic, \"Sample Data here - Mike Bonifacio\")\n      .subscribe((str) => {\n        console.log(\"ENCRYPTED STRING: \", str);\n        testSequence.next('encrypted string success');\n      })\n\n    })\n\n    const enc = \"r7UOuEGBZ6jbVTOIBuv9jFOEtRiedmS27hfW40k7XKCTsQ5VhWup0qu2BA2ANZaGKii/uehJ/RSPiyfGbJ6leJrat0mA1hPqH/XodaBzLMDigvdYM1NSXFZMDa40OpLUIXbPlAvybjcGu7Bal+LMA8htHrFu/OmM/fHI66xOzzpuXSYx0OkWjtY81rUQ1FFkvrkx2jGFPZ0p+Nw/v3Q4cJnet6V63vCueFlD749VMcVXo7pvz4AIPpB+IOy3kbxaYTPakLVioJERU6GFMXWkECuRvohhS9CETcORZtRVRkvhcHk3lxgIhfqojUKYgD6K5dDELDPsWIS+iTG1XIQIlg==\";\n\n    // DECRYPTION\n    this.pemToCryptoKey(\n      privateKey,\n      algorithm,\n      false,\n      [\"decrypt\"],\n      \"pkcs8\"\n    ).subscribe((key) => {\n\n      // console.log(\"DECRYPT ===\", key)\n\n      this.decryptData(key, enc)\n      .pipe(\n        catchError(err => {\n          console.log(\"ERROR: \", err);\n          return EMPTY\n        })\n      ).subscribe((str) => {\n        console.log(\"DECRYPTED STRING: \", str);\n        testSequence.next('decrypted string success');\n      })\n\n    })\n\n    return testSequence$;\n  };\n}\n"]}

package/esm2022/lib/services/utils/encryption/encryption-test.service.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class EncryptionTestService {
+    constructor() { }
+    isBase64(str) {
+        const base64Pattern = /^(?:[A-Z0-9+/]{4})*(?:[A-Z0-9+/]{2}==|[A-Z0-9+/]{3}=)?$/i;
+        return base64Pattern.test(str);
+    }
+    isHexadecimal(str) {
+        const hexPattern = /^[0-9a-fA-F]+$/;
+        return hexPattern.test(str) && (str.length % 2 === 0);
+    }
+    hasHighEntropy(str) {
+        const uniqueChars = new Set(str).size;
+        return uniqueChars > str.length * 0.6;
+    }
+    isEncrypted(str) {
+        if (typeof str !== 'string') {
+            return false;
+        }
+        if (this.isBase64(str) || this.isHexadecimal(str)) {
+            return true;
+        }
+        return this.hasHighEntropy(str);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EncryptionTestService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EncryptionTestService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EncryptionTestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/utils/encryption/index.mjs

@@ -0,0 +1,4 @@
+export * from "./asymmetrical-encryption.service";
+export * from './symmetrical-encryption.service';
+export * from './random';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9odHRwLXJlcXVlc3QtbWFuYWdlci9zcmMvbGliL3NlcnZpY2VzL3V0aWxzL2VuY3J5cHRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLGtDQUFrQyxDQUFDO0FBRWpELGNBQWMsVUFBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vYXN5bW1ldHJpY2FsLWVuY3J5cHRpb24uc2VydmljZVwiO1xuZXhwb3J0ICogZnJvbSAnLi9zeW1tZXRyaWNhbC1lbmNyeXB0aW9uLnNlcnZpY2UnO1xuXG5leHBvcnQgKiBmcm9tICcuL3JhbmRvbSc7XG5cbiJdfQ==

package/esm2022/lib/services/utils/encryption/random.mjs

@@ -0,0 +1,52 @@
+export const Random = () => {
+    const typedArray = new Uint8Array(1);
+    const randomValue = crypto.getRandomValues(typedArray)[0];
+    const randomFloat = randomValue / Math.pow(2, 8);
+    return randomFloat;
+};
+export const RandomNumber = (min, max) => {
+    return Math.floor(Random() * max) + min;
+};
+export const RandomNumbers = (min, max, length) => {
+    const numbers = [];
+    for (let i = 0; i < length; i++)
+        numbers.push(Math.floor(Random() * max) + min);
+    return numbers;
+};
+export const RandomNumbersUnique = (min, max, length) => {
+    let count = 0;
+    // Adjust the length if it exceeds the number of unique numbers possible in the range
+    if (length > (max - min + 1)) {
+        console.error('error encountered');
+        length = max - min + 1;
+    }
+    console.log('length', length);
+    const numbers = [];
+    const maxAttempts = length * 100; // Safeguard to prevent infinite loops
+    while (numbers.length < length && count < maxAttempts) {
+        const num = Math.floor(Random() * max) + min;
+        if (!numbers.includes(num)) {
+            numbers.push(num);
+        }
+    }
+    if (count >= maxAttempts) {
+        throw new Error('Maximum attempts exceeded while generating unique numbers');
+    }
+    return numbers;
+};
+export const RandomStr = () => {
+    const typedArray = new Uint8Array(8);
+    const array = new Uint32Array(1);
+    crypto.getRandomValues(array);
+    return array[0].toString(36);
+};
+export const RandomSignature = () => {
+    const typedArray = new Uint8Array(8);
+    const array = new Uint32Array(1);
+    crypto.getRandomValues(array);
+    return array[0];
+};
+export const UUID = () => {
+    return self.crypto.randomUUID();
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/utils/encryption/symmetrical-encryption.service.mjs

@@ -0,0 +1,77 @@
+import { Injectable, inject } from '@angular/core';
+import * as CryptoJS from 'crypto-js';
+import { RandomSignature } from './random';
+import { AppService } from '../app.service';
+import * as i0 from "@angular/core";
+export class SymmetricalEncryptionService {
+    constructor() {
+        this.appService = inject(AppService);
+        // TODO: The APP ID is not a string, it is a function
+        this.appID = (this.appService.appID) ? this.appService.appID : '';
+        if (this.appID === '')
+            console.warn('No App Key has been define');
+    }
+    generateCipherKey() {
+        return (RandomSignature().toString() + RandomSignature().toString()).substring(0, 8);
+    }
+    encrypt(str, key = this.appID) {
+        if (!str || key === '')
+            return '';
+        let _key = CryptoJS.enc.Utf8.parse(key);
+        let _iv = CryptoJS.enc.Utf8.parse(key);
+        try {
+            const encrypted = CryptoJS.AES.encrypt(JSON.stringify(str), _key, {
+                keySize: 16,
+                iv: _iv,
+                mode: CryptoJS.mode.ECB,
+                padding: CryptoJS.pad.Pkcs7
+            });
+            return encrypted.toString();
+        }
+        catch (error) {
+            console.log(error);
+        }
+        return;
+    }
+    decrypt(str, key = this.appID) {
+        if (!str || key === '')
+            return;
+        let _key = CryptoJS.enc.Utf8.parse(key);
+        let _iv = CryptoJS.enc.Utf8.parse(key);
+        try {
+            return CryptoJS.AES.decrypt(str, _key, {
+                keySize: 16,
+                iv: _iv,
+                mode: CryptoJS.mode.ECB,
+                padding: CryptoJS.pad.Pkcs7
+            }).toString(CryptoJS.enc.Utf8);
+        }
+        catch (error) {
+            console.log(error);
+        }
+        return;
+    }
+    createSignature(url, len = 16) {
+        const sig = CryptoJS.SHA256(url).toString(CryptoJS.enc.Hex);
+        return sig.substring(0, len).toUpperCase();
+    }
+    normalizeURL(url) {
+        const normalizedURL = url.replace(/(https?:\/\/)?(www\.)?/, '').replace(/\/+$/, '');
+        return normalizedURL;
+    }
+    generateSignature(url) {
+        const normalizedURL = this.normalizeURL(url);
+        const hash = CryptoJS.SHA256(normalizedURL);
+        const signature = hash.toString(CryptoJS.enc.Hex);
+        return signature;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SymmetricalEncryptionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SymmetricalEncryptionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SymmetricalEncryptionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/utils/headers.service.mjs

@@ -0,0 +1,21 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class HeadersService {
+    constructor() {
+        this.headers = {};
+    }
+    generateHeaders(headers) {
+        const allHeaders = headers ? { ...this.headers, ...headers } : {};
+        return { headers: new HttpHeaders(allHeaders) };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HeadersService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HeadersService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: HeadersService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhZGVycy5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvaHR0cC1yZXF1ZXN0LW1hbmFnZXIvc3JjL2xpYi9zZXJ2aWNlcy91dGlscy9oZWFkZXJzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBTyxjQUFjO0lBSDNCO1FBS0UsWUFBTyxHQUFHLEVBQUUsQ0FBQTtLQVNiO0lBUEMsZUFBZSxDQUFDLE9BQWdDO1FBRTlDLE1BQU0sVUFBVSxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxHQUFHLElBQUksQ0FBQyxPQUFPLEVBQUUsR0FBRyxPQUFPLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFBO1FBQ2pFLE9BQU8sRUFBRSxPQUFPLEVBQUUsSUFBSSxXQUFXLENBQUMsVUFBVSxDQUFDLEVBQUUsQ0FBQTtJQUVqRCxDQUFDOytHQVRVLGNBQWM7bUhBQWQsY0FBYyxjQUZiLE1BQU07OzRGQUVQLGNBQWM7a0JBSDFCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSHR0cEhlYWRlcnMgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5pbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIEhlYWRlcnNTZXJ2aWNlIHtcblxuICBoZWFkZXJzID0ge31cblxuICBnZW5lcmF0ZUhlYWRlcnMoaGVhZGVycz86IFJlY29yZDxzdHJpbmcsIHN0cmluZz4pOiB7IGhlYWRlcnM6IEh0dHBIZWFkZXJzIH0ge1xuXG4gICAgY29uc3QgYWxsSGVhZGVycyA9IGhlYWRlcnMgPyB7IC4uLnRoaXMuaGVhZGVycywgLi4uaGVhZGVycyB9IDoge31cbiAgICByZXR1cm4geyBoZWFkZXJzOiBuZXcgSHR0cEhlYWRlcnMoYWxsSGVhZGVycykgfVxuXG4gIH1cblxufVxuIl19

package/esm2022/lib/services/utils/index.mjs

@@ -0,0 +1,6 @@
+export * from './app.service';
+export * from './headers.service';
+export * from './path-query.service';
+export * from './utils.service';
+export * from './encryption/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9odHRwLXJlcXVlc3QtbWFuYWdlci9zcmMvbGliL3NlcnZpY2VzL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGlCQUFpQixDQUFDO0FBRWhDLGNBQWMsb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FwcC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vaGVhZGVycy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcGF0aC1xdWVyeS5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbHMuc2VydmljZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vZW5jcnlwdGlvbi9pbmRleCc7XG5cbiJdfQ==

package/esm2022/lib/services/utils/path-query.service.mjs

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PathQueryService {
+    constructor() {
+        this.removeEmptyParams = (obj) => Object.fromEntries(Object.entries(obj)
+            .map(([key, value]) => [key, value && typeof value === 'object' ? this.removeEmptyParams(value) : value])
+            .filter(([_, value]) => value !== undefined && value !== ""));
+    }
+    buildAPIPath(server, params) {
+        server = (Array.isArray(server)) ? server.join('/') : server;
+        const pathObjects = (params) ? params.filter((path) => (!this.isObject(path))) : [];
+        const queryObjects = (params) ? params.filter((path) => (this.isObject(path))) : [];
+        const query = this.removeEmptyParams(queryObjects.reduce((r, c) => {
+            Object.entries(c).forEach(([key, value]) => {
+                r[key] = Array.isArray(value) ? value.join(',') : value;
+            });
+            return r;
+        }, {}));
+        let path = this.buildRestPath(server, pathObjects);
+        return (Object.keys(query).length > 0) ? path + '?' + this.buildQueryPath(query) : path;
+    }
+    buildRestPath(server, params) {
+        server = (server.charAt(0) === '/') ? server.substring(1) : server;
+        return this.cleanUrlPath(server + '/' + params.join('/'));
+    }
+    buildQueryPath(params) {
+        const searchParams = new URLSearchParams();
+        for (const key in params) {
+            if (Array.isArray(params[key])) {
+                params[key].forEach((value) => searchParams.append(key, value));
+            }
+            else {
+                searchParams.append(key, params[key]);
+            }
+        }
+        return searchParams.toString();
+    }
+    cleanUrlPath(str) {
+        return str.replace(/([^:]\/)\/+/g, "$1").replace(/\/$/, '');
+    }
+    isObject(val) {
+        return (val === null) ? false : ((typeof val === 'function') || (typeof val === 'object'));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PathQueryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PathQueryService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: PathQueryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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