http-request-manager 18.15.32 → 18.15.34

package/src/lib/services/store-state-manager-service/store-state-manager.service.ts

@@ -0,0 +1,153 @@
+import { LocalStorageManagerService } from '../local-storage-manager-service/local-storage-manager.service';
+import { inject, Injectable } from '@angular/core';
+import { ComponentStore } from '@ngrx/component-store';
+import { StateStorageOptions } from './models/state-storage-options.model';
+import { StateOperationResult } from './models/state-operation-result.model';
+import { BehaviorSubject, Observable, Subscription, take } from 'rxjs';
+
+export interface StateStoreManagerData<T> {}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class StoreStateManagerService<T extends object = StateStoreManagerData<any>> extends ComponentStore<T> {
+
+  localStorageManagerService = inject(LocalStorageManagerService)
+
+  subscriptions = new Subscription
+  settings: any = null
+
+  private isRestoring = false
+
+  private operationResult = new BehaviorSubject<StateOperationResult | null>(null)
+  operationResult$: Observable<StateOperationResult | null> = this.operationResult.asObservable()
+
+  constructor(
+    private options: StateStorageOptions = StateStorageOptions.adapt()
+  ) {
+    super(StoreStateManagerService.init(options))
+    this.init(options)
+  }
+
+  private static init(options: StateStorageOptions): any {
+
+    const model = options?.model
+    return (model) ? (model as () => any)() : {}
+
+  }
+
+  init(options?: StateStorageOptions) {
+
+    this.settings = options
+
+    this.localStorageManagerService.createStore({
+      name: this.settings?.store,
+      data: this.settings?.model(),
+      options: this.settings?.options,
+    })
+
+    this.localStorageManagerService.store$(this.settings?.store)
+    .subscribe(data => this.setState(data))
+
+  }
+
+  restoreState(): Subscription {
+
+    return this.localStorageManagerService.store$(this.settings?.store)
+    .pipe(take(1))
+    .subscribe(data => {
+      this.updateData(data)
+    })
+
+  }
+
+  updateState(state: any) {
+    if(this.isRestoring) return
+    this.localStorageManagerService.updateStore({
+      name: this.settings?.store,
+      data: state
+    })
+
+  }
+
+  // Selectors
+  readonly data$ = this.select((state: any) => {
+    const model = this.options.model;
+    return (typeof model === 'function' && !model.prototype) ? model(state) : state
+  });
+
+  // Updaters
+  readonly updateData = this.updater((state, data: any) => {
+
+    const key = Object.keys(data)[0]
+    const hasKey = Object.keys(state).includes(key)
+
+    if (!hasKey) return state
+    const newState = { ...state, [key]: data[key] }
+    this.updateState(newState)
+    return { ...state, ...newState }
+
+  })
+
+  createRecord(key: string, value: any) {
+    try {
+      this.updateData({ [key]: value })
+      this.operationResult.next(StateOperationResult.adapt({
+        success: true,
+        operation: 'CREATE',
+        key,
+        value,
+      }))
+    } catch (error: any) {
+      this.operationResult.next(StateOperationResult.adapt({
+        success: false,
+        operation: 'CREATE',
+        key,
+        error: error?.message || 'Create failed',
+      }))
+    }
+  }
+
+  updateRecord(key: string, value: any) {
+    try {
+      this.updateData({ [key]: value })
+      this.operationResult.next(StateOperationResult.adapt({
+        success: true,
+        operation: 'UPDATE',
+        key,
+        value,
+      }))
+    } catch (error: any) {
+      this.operationResult.next(StateOperationResult.adapt({
+        success: false,
+        operation: 'UPDATE',
+        key,
+        error: error?.message || 'Update failed',
+      }))
+    }
+  }
+
+  deleteRecord(key: string) {
+    try {
+      const currentState = this.get()
+      if (currentState && key in currentState) {
+        const { [key]: removed, ...rest } = currentState as any
+        this.setState(rest as T)
+        this.updateState(rest)
+      }
+      this.operationResult.next(StateOperationResult.adapt({
+        success: true,
+        operation: 'DELETE',
+        key,
+      }))
+    } catch (error: any) {
+      this.operationResult.next(StateOperationResult.adapt({
+        success: false,
+        operation: 'DELETE',
+        key,
+        error: error?.message || 'Delete failed',
+      }))
+    }
+  }
+
+}

package/src/lib/services/utils/app.service.spec.ts

@@ -0,0 +1,25 @@
+import { TestBed } from '@angular/core/testing';
+import { APP_ID } from '@angular/core';
+import { AppService } from './app.service';
+
+describe('AppService', () => {
+  let service: AppService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        AppService,
+        { provide: APP_ID, useValue: 'test-app-id' }
+      ]
+    });
+    service = TestBed.inject(AppService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should have appID assigned from APP_ID', () => {
+    expect(service.appID).toBe('test-app-id');
+  });
+});

package/src/lib/services/utils/app.service.ts

@@ -0,0 +1,21 @@
+import { APP_ID, Inject, Injectable } from '@angular/core';
+
+// Must provide a value for APP_ID in AppModule->Providers
+// providers: [
+//   {
+//     provide: APP_ID,
+//     useValue: "056991ac-3537-43ab-b5b9-83edf6554eff",
+//   },
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AppService {
+
+  appID: string
+
+  constructor(@Inject(APP_ID) private id: string) {
+    this.appID = this.id
+  }
+
+}

package/src/lib/services/utils/encryption/README.md

@@ -0,0 +1,79 @@
+# Generate a Key Pair on Mac
+
+To generate a key pair on a Mac, you can use the built-in openssl command-line tool. This tool is available on most Unix-like operating systems, including macOS. Below are the steps to generate an RSA key pair using openssl:
+
+### Step 1: Open Terminal
+
+Open the Terminal application on your Mac. You can find it in the Utilities folder within the Applications folder, or you can use Spotlight to search for "Terminal".
+
+### Step 2: Generate the Private Key
+
+Run the following command to generate a 2048-bit RSA private key:
+
+```sh
+openssl genpkey -algorithm RSA -out private_key.pem -pkeyopt rsa_keygen_bits:2048
+```
+
+### Step 3: Generate the Public Key
+
+Run the following command to extract the public key from the private key:
+
+```sh
+openssl rsa -pubout -in private_key.pem -out public_key.pem
+```
+
+### Step 4: View the Keys (Optional)
+
+You can view the contents of the generated key files using the cat command:
+
+To view the private key:
+
+```sh
+cat private_key.pem
+```
+
+To view the public key:
+
+```sh
+cat public_key.pem
+```
+
+    -----BEGIN PRIVATE KEY-----
+    MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQC2mvvEWn/aMikX
+    A8+/Po2R4+PHwC9wxa10fr75sR9Wbuq8NY/yY174JHR4rRmyV8EnKEfyoTzfsvTO
+    858lPD4DuUKESh+NDKiLNUdY4isrR060rxzJn+30OzKkZIHWhIZY3jqEw7C+glMV
+    Fmphtci4WQqPYwi1rX3YswE0MJhF/a+HCZ5erDmET/PFZJtTSsx47zbeck2Mnfta
+    KpF/wS9jYtpUFrf/vSuTo4Q0libauiFwPgCeYTGEBGGbKVnbAbM71qqmjOxT0ItW
+    TbsrGWG54G6vTxg/mnzxpJfMNlVOogv9u2YcG0lEQ/xo9P88WBWPdE0TK5V37GOq
+    3twvUruHAgMBAAECggEAThZZqr6OpQbFRofFO8GqtaQQAJghUWbfRY176ngBcCtP
+    azu2ek9fSdsBCafwcLERMscJeWrVBs5W3PcWa8xmsp3zIXI3KtCqdJlMkOhq0H+W
+    WzL1Kw2eqs3z2pP2Z/9VGkSyHps2hklh8QccZ/teQeMl3mpZy6NMyTHHRoOvYmIg
+    TBhDPL+WWJXPVlgKle3RRDVeD1JVo5XmsOW4I8FRyp5f7BZE1IwPTNDUATAtwC8u
+    dHHo1rTkWIk2gxVPRcH61w8ceij4VPv7Sk7iFobcLkscTwbTzondU3YssSYEmayW
+    5+qhIbHXWnn4FVMPVrDUORVAW8naCrVVBCYGWFDnQQKBgQDcsQ07EaYWDnRQ0xcq
+    5hTQUnd137CKNQcLXJ8T+ghuj5v0ZhPpu3YZDjm+rX52mrFN4+kEMKkCjFJAeKaI
+    omqKb/i57t7tcQKsbGdtUyRt7PirnHed7dlEo0ElwBWr58hTcUuTnoIiQM3sgmpn
+    VrlntlWpVWr0hoJMxRS6Pb6xQQKBgQDT0gVdNm0+ZrBKDWWKkeaQHHyxdva8Dt6C
+    NEjP+uU16hF6CsPGCvDuNA9PMIqGHR914aeEwYWtma6/zI1T74jhlUiyAHkpW373
+    +xNWmruq8k3UlVBK8JIjH/LOXNV5Gw85yLJwokhl6A8m4DSMkDJZTLVXfYQ24su1
+    TMDz0yhyxwKBgA/jNx6fgKNp2vnOmIZgFfOBXFRCDEWG18D7pAAeKek7sXCAwMI8
+    2p2nJoURnF8Rd94xoB7LGf+y9mDpzqNbfewFb5SDG81gK18aVr/KEn9PZf+Evh/C
+    dbe5QQFkuKqtfwBy0YwJBzlMDQcPxHU4CxTqTXRpT8/Wtx6ruXhG5amBAoGANXmC
+    8ypHYAaKoNdK+DWnMGCQtjijR4y1bceHTkI31WmXKelHzVp7wpcP+lz1y6/Ufm0O
+    XnyAo/f1XuRkFXmWY+TNKmrmK6O2pSIUmruLfzeWoIFleNXM/uMU6DYVinJjYKIj
+    Mj416swv7w+RFJ9epp6v9Ttxwm11IfsThzqarocCgYAPbtk6kqJwxq5I49NoC3Nm
+    WozUs31UywHJLS4JeudityA7ZTD8kULyhCig+Mrupiu3qLAmFtJzYFFIoP4msIOC
+    xMQ2qHvUyX9BwpONDwZ6fjwQYa8/kt22MelVICKqDpyYlOipV/YRKMNXsaQJd6xB
+    pkaCFGUW4xoRwTR/So/RnQ==
+    -----END PRIVATE KEY-----
+    (base) mike.boni@Mikes-MacBook-Pro ~ % cat public_key.pem
+
+    -----BEGIN PUBLIC KEY-----
+    MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtpr7xFp/2jIpFwPPvz6N
+    kePjx8AvcMWtdH6++bEfVm7qvDWP8mNe+CR0eK0ZslfBJyhH8qE837L0zvOfJTw+
+    A7lChEofjQyoizVHWOIrK0dOtK8cyZ/t9DsypGSB1oSGWN46hMOwvoJTFRZqYbXI
+    uFkKj2MIta192LMBNDCYRf2vhwmeXqw5hE/zxWSbU0rMeO823nJNjJ37WiqRf8Ev
+    Y2LaVBa3/70rk6OENJYm2rohcD4AnmExhARhmylZ2wGzO9aqpozsU9CLVk27Kxlh
+    ueBur08YP5p88aSXzDZVTqIL/btmHBtJREP8aPT/PFgVj3RNEyuVd+xjqt7cL1K7
+    hwIDAQAB
+    -----END PUBLIC KEY-----

package/src/lib/services/utils/encryption/asymmetrical-encryption.service.ts

@@ -0,0 +1,282 @@
+import { Injectable } from '@angular/core';
+
+import { BehaviorSubject, EMPTY, Observable, from, of } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AsymmetricalEncryptionService {
+
+  constructor() {}
+
+  generateKeyPair(modulusLength = 2048): Observable<CryptoKeyPair> {
+  
+    // modulusLength - 1024, 2048, 4096
+    // hash - SHA-256
+
+   return from(crypto.subtle.generateKey(
+      {
+        name: "RSA-OAEP",
+        modulusLength,
+        publicExponent: new Uint8Array([1, 0, 1]), // 65537
+        hash: { name: "SHA-256" }
+      },
+      true, // Extractable keys
+      ["encrypt", "decrypt"]
+    ))
+
+  }
+
+  encryptData(publicKey: CryptoKey, data: string) {
+
+    const encodedData = new TextEncoder().encode(data)
+
+    return from(crypto.subtle.encrypt(
+      {
+        name: "RSA-OAEP"
+      },
+      publicKey,
+      encodedData
+    )).pipe(
+      map(enc => this.arrayBufferToBase64(enc))
+    )
+
+  }
+
+  decryptData(privateKey: CryptoKey, encryptedData: string) {
+
+    const encStr = this.base64ToArrayBuffer(encryptedData)
+
+    return from(crypto.subtle.decrypt(
+      {
+        name: "RSA-OAEP"
+      },
+      privateKey,
+      encStr
+    ).then(decryptedData => {
+      return new TextDecoder().decode(decryptedData)
+    }))
+
+  }
+
+  pemToArrayBuffer(pem: string): ArrayBuffer {
+
+    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: string): ArrayBuffer {
+    
+    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: ArrayBuffer): string {
+
+    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: string, 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: string, 
+    algorithm: RsaHashedKeyGenParams, 
+    extractable: boolean, 
+    keyUsages: KeyUsage[],
+    format: any = "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(): Observable<string> {
+    const testSequence: BehaviorSubject<string> = new BehaviorSubject<string>("");
+    const testSequence$: Observable<string> = 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(): Observable<string> {
+    const testSequence: BehaviorSubject<string> = new BehaviorSubject<string>("");
+    const testSequence$: Observable<string> = 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: RsaHashedKeyGenParams = {
+      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$;
+  };
+}

package/src/lib/services/utils/encryption/encryption-test.service.ts

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class EncryptionTestService {
+
+  constructor() { }
+
+  private isBase64(str: string): boolean {
+    const base64Pattern = /^(?:[A-Z0-9+/]{4})*(?:[A-Z0-9+/]{2}==|[A-Z0-9+/]{3}=)?$/i;
+    return base64Pattern.test(str);
+  }
+
+  private isHexadecimal(str: string): boolean {
+    const hexPattern = /^[0-9a-fA-F]+$/;
+    return hexPattern.test(str) && (str.length % 2 === 0);
+  }
+
+  private hasHighEntropy(str: string): boolean {
+    const uniqueChars = new Set(str).size;
+    return uniqueChars > str.length * 0.6;
+  }
+
+  isEncrypted(str: string): boolean {
+
+    if (typeof str !== 'string') {
+      return false;
+    }
+
+    if (this.isBase64(str) || this.isHexadecimal(str)) {
+      return true;
+    }
+
+    return this.hasHighEntropy(str);
+
+  }
+
+}

package/src/lib/services/utils/encryption/index.ts

@@ -0,0 +1,5 @@
+export * from "./asymmetrical-encryption.service";
+export * from './symmetrical-encryption.service';
+
+export * from './random';
+

package/src/lib/services/utils/encryption/random.ts

@@ -0,0 +1,81 @@
+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: number, max: number) => {
+  return Math.floor(Random() * max) + min
+}
+
+export const RandomNumbers = (min: number, max: number, length: number) => {
+  const numbers: number[] = []
+  for (let i = 0; i < length; i++) numbers.push(Math.floor(Random() * max) + min)
+  return numbers
+}
+
+export const RandomNumbersUnique = (min: number, max: number, length: number) => {
+  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: number[] = [];
+  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()
+}
+
+/**
+ * Generate a UUID string (legacy format)
+ */
+export const UUID_STR = (): string => {
+  const s4 = () => {
+    return Math.floor((1 + Random()) * 0x10000)
+      .toString(16)
+      .substring(1);
+  };
+  return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
+};
+
+