@sudoplatform/sudo-common 6.3.0 → 7.0.0

package/src/sudoKeyManager/sudoKeyManager.ts

@@ -68,6 +68,15 @@ export interface SudoKeyManager {
    *
    * @param name The name of the symmetric key.
    */
+  doesSymmetricKeyExist(name: string): Promise<boolean>
+
+  /**
+   * Checks to see if the specified symmetric key exists.
+   *
+   * @param name The name of the symmetric key.
+   *
+   * @deprecated Use doesSymmetricKeyExist
+   */
   doesSymmetricKeyExists(name: string): Promise<boolean>
 
   /**
@@ -99,6 +108,15 @@ export interface SudoKeyManager {
    *
    * @param name The name of the private key.
    */
+  doesPrivateKeyExist(name: string): Promise<boolean>
+
+  /**
+   * Checks to see if the specified private key exists.
+   *
+   * @param name The name of the private key.
+   *
+   * @deprecated Use doesPrivateKeyExist
+   */
   doesPrivateKeyExists(name: string): Promise<boolean>
 
   /**
@@ -111,6 +129,13 @@ export interface SudoKeyManager {
    */
   addPublicKey(key: ArrayBuffer, name: string): Promise<void>
 
+  /**
+   * Deletes the specified public key from the secure store.
+   *
+   * @param name The name of the public key to be removed.
+   */
+  deletePublicKey(name: string): Promise<void>
+
   /**
    * Retrieves the public key from the secure store.
    *
@@ -129,6 +154,34 @@ export interface SudoKeyManager {
    */
   deleteKeyPair(name: string): Promise<void>
 
+  /**
+   * Generates a signature for the given data with the specified private key.
+   *
+   * @param name The name of the private key to use for generation.
+   * @param data The data to sign.
+   *
+   * @returns Data signature or undefined if the private key is not found.
+   */
+  generateSignatureWithPrivateKey(
+    name: string,
+    data: ArrayBuffer,
+  ): Promise<ArrayBuffer>
+
+  /**
+   * Verifies the given data against the provided signature using the specified public key.
+   *
+   * @param name The name of the public key to use for validation.
+   * @param data The data to verify
+   * @param signature The signature to verify against
+   *
+   * @returns True if the data and signature could be successfully verified
+   */
+  verifySignatureWithPublicKey(
+    name: string,
+    data: ArrayBuffer,
+    signature: ArrayBuffer,
+  ): Promise<boolean>
+
   /**
    * @deprecated Use version with `options` param.
    *
@@ -393,6 +446,10 @@ export class DefaultSudoKeyManager implements SudoKeyManager {
     return this.sudoCryptoProvider.getSymmetricKey(name)
   }
 
+  public doesSymmetricKeyExist(name: string): Promise<boolean> {
+    return this.sudoCryptoProvider.doesSymmetricKeyExists(name)
+  }
+
   public doesSymmetricKeyExists(name: string): Promise<boolean> {
     return this.sudoCryptoProvider.doesSymmetricKeyExists(name)
   }
@@ -413,6 +470,10 @@ export class DefaultSudoKeyManager implements SudoKeyManager {
     return this.sudoCryptoProvider.getPrivateKey(name)
   }
 
+  public doesPrivateKeyExist(name: string): Promise<boolean> {
+    return this.sudoCryptoProvider.doesPrivateKeyExists(name)
+  }
+
   public doesPrivateKeyExists(name: string): Promise<boolean> {
     return this.sudoCryptoProvider.doesPrivateKeyExists(name)
   }
@@ -421,6 +482,10 @@ export class DefaultSudoKeyManager implements SudoKeyManager {
     return this.sudoCryptoProvider.addPublicKey(key, name)
   }
 
+  public deletePublicKey(name: string): Promise<void> {
+    return this.sudoCryptoProvider.deletePublicKey(name)
+  }
+
   public getPublicKey(name: string): Promise<PublicKey | undefined> {
     return this.sudoCryptoProvider.getPublicKey(name)
   }
@@ -429,17 +494,34 @@ export class DefaultSudoKeyManager implements SudoKeyManager {
     return this.sudoCryptoProvider.deleteKeyPair(name)
   }
 
+  public generateSignatureWithPrivateKey(
+    name: string,
+    data: ArrayBuffer,
+  ): Promise<ArrayBuffer> {
+    return this.sudoCryptoProvider.generateSignatureWithPrivateKey(name, data)
+  }
+
+  verifySignatureWithPublicKey(
+    name: string,
+    data: ArrayBuffer,
+    signature: ArrayBuffer,
+  ): Promise<boolean> {
+    return this.sudoCryptoProvider.verifySignatureWithPublicKey(
+      name,
+      data,
+      signature,
+    )
+  }
+
   public encryptWithSymmetricKey(
     key: ArrayBuffer,
     data: ArrayBuffer,
     ivOrOptions?: ArrayBuffer | SymmetricEncryptionOptions,
   ): Promise<ArrayBuffer> {
     if (BufferUtil.isArrayBuffer(ivOrOptions)) {
-      return this.sudoCryptoProvider.encryptWithSymmetricKey(
-        key,
-        data,
-        ivOrOptions,
-      )
+      return this.sudoCryptoProvider.encryptWithSymmetricKey(key, data, {
+        iv: ivOrOptions,
+      })
     } else {
       return this.sudoCryptoProvider.encryptWithSymmetricKey(
         key,
@@ -455,11 +537,9 @@ export class DefaultSudoKeyManager implements SudoKeyManager {
     ivOrOptions?: ArrayBuffer | SymmetricEncryptionOptions,
   ): Promise<ArrayBuffer> {
     if (BufferUtil.isArrayBuffer(ivOrOptions)) {
-      return this.sudoCryptoProvider.decryptWithSymmetricKey(
-        key,
-        data,
-        ivOrOptions,
-      )
+      return this.sudoCryptoProvider.decryptWithSymmetricKey(key, data, {
+        iv: ivOrOptions,
+      })
     } else {
       return this.sudoCryptoProvider.decryptWithSymmetricKey(
         key,
@@ -475,11 +555,9 @@ export class DefaultSudoKeyManager implements SudoKeyManager {
     ivOrOptions?: ArrayBuffer | SymmetricEncryptionOptions,
   ): Promise<ArrayBuffer> {
     if (BufferUtil.isArrayBuffer(ivOrOptions)) {
-      return this.sudoCryptoProvider.encryptWithSymmetricKeyName(
-        name,
-        data,
-        ivOrOptions,
-      )
+      return this.sudoCryptoProvider.encryptWithSymmetricKeyName(name, data, {
+        iv: ivOrOptions,
+      })
     } else {
       return this.sudoCryptoProvider.encryptWithSymmetricKeyName(
         name,
@@ -495,11 +573,9 @@ export class DefaultSudoKeyManager implements SudoKeyManager {
     ivOrOptions?: ArrayBuffer | SymmetricEncryptionOptions,
   ): Promise<ArrayBuffer> {
     if (BufferUtil.isArrayBuffer(ivOrOptions)) {
-      return this.sudoCryptoProvider.decryptWithSymmetricKeyName(
-        name,
-        data,
-        ivOrOptions,
-      )
+      return this.sudoCryptoProvider.decryptWithSymmetricKeyName(name, data, {
+        iv: ivOrOptions,
+      })
     } else {
       return this.sudoCryptoProvider.decryptWithSymmetricKeyName(
         name,

package/test/unit/sudoKeyManager.spec.ts

@@ -177,6 +177,25 @@ describe('DefaultSudoKeyManager', () => {
     })
   })
 
+  describe('doesSymmetricKeyExist', () => {
+    it('should call crypto provider doesSymmetricKeyExists', async () => {
+      when(
+        sudoCryptoProviderMock.doesSymmetricKeyExists(anything()),
+      ).thenResolve(true)
+
+      await expect(
+        sudoKeyManager.doesSymmetricKeyExist('VpnKey'),
+      ).resolves.toEqual(true)
+      const [actualKey] = capture(
+        sudoCryptoProviderMock.doesSymmetricKeyExists,
+      ).first()
+      expect(actualKey).toStrictEqual('VpnKey')
+
+      verify(sudoCryptoProviderMock.doesSymmetricKeyExists(anything())).once()
+      verify(sudoCryptoProviderMock.doesSymmetricKeyExist(anything())).never()
+    })
+  })
+
   describe('doesSymmetricKeyExists', () => {
     it('should call crypto provider doesSymmetricKeyExists', async () => {
       when(
@@ -192,6 +211,7 @@ describe('DefaultSudoKeyManager', () => {
       expect(actualKey).toStrictEqual('VpnKey')
 
       verify(sudoCryptoProviderMock.doesSymmetricKeyExists(anything())).once()
+      verify(sudoCryptoProviderMock.doesSymmetricKeyExist(anything())).never()
     })
   })
 
@@ -281,6 +301,26 @@ describe('DefaultSudoKeyManager', () => {
     })
   })
 
+  describe('doesPrivateKeyExist', () => {
+    it('should call crypto provider doesPrivateKeyExists', async () => {
+      when(sudoCryptoProviderMock.doesPrivateKeyExists(anything())).thenResolve(
+        true,
+      )
+
+      await expect(
+        sudoKeyManager.doesPrivateKeyExist('VpnKeyPair'),
+      ).resolves.toBeTruthy()
+
+      const [actualKeyName] = capture(
+        sudoCryptoProviderMock.doesPrivateKeyExists,
+      ).first()
+      expect(actualKeyName).toStrictEqual('VpnKeyPair')
+
+      verify(sudoCryptoProviderMock.doesPrivateKeyExists(anything())).once()
+      verify(sudoCryptoProviderMock.doesPrivateKeyExist(anything())).never()
+    })
+  })
+
   describe('doesPrivateKeyExists', () => {
     it('should call crypto provider doesPrivateKeyExists', async () => {
       when(sudoCryptoProviderMock.doesPrivateKeyExists(anything())).thenResolve(
@@ -297,6 +337,7 @@ describe('DefaultSudoKeyManager', () => {
       expect(actualKeyName).toStrictEqual('VpnKeyPair')
 
       verify(sudoCryptoProviderMock.doesPrivateKeyExists(anything())).once()
+      verify(sudoCryptoProviderMock.doesPrivateKeyExist(anything())).never()
     })
   })
 
@@ -393,8 +434,8 @@ describe('DefaultSudoKeyManager', () => {
       expect(actualKeyName).toStrictEqual('VpnKey')
       expect(actualData).toStrictEqual(decrypted)
       expect(actualOptions).toBeDefined()
-      expect(actualOptions.iv).toStrictEqual(iv)
-      expect(actualOptions.algorithm).toBeUndefined()
+      expect(actualOptions!.iv).toStrictEqual(iv)
+      expect(actualOptions!.algorithm).toBeUndefined()
 
       verify(
         sudoCryptoProviderMock.encryptWithSymmetricKeyName(
@@ -430,8 +471,8 @@ describe('DefaultSudoKeyManager', () => {
       expect(actualKeyName).toStrictEqual('VpnKey')
       expect(actualData).toStrictEqual(decrypted)
       expect(actualOptions).toBeDefined()
-      expect(actualOptions.iv).toStrictEqual(options.iv)
-      expect(actualOptions.algorithm).toStrictEqual(options.algorithm)
+      expect(actualOptions!.iv).toStrictEqual(options.iv)
+      expect(actualOptions!.algorithm).toStrictEqual(options.algorithm)
 
       verify(
         sudoCryptoProviderMock.encryptWithSymmetricKeyName(
@@ -492,8 +533,8 @@ describe('DefaultSudoKeyManager', () => {
       expect(actualKey).toStrictEqual(symmetricKey)
       expect(actualData).toStrictEqual(encrypted)
       expect(actualOptions).toBeDefined()
-      expect(actualOptions.iv).toStrictEqual(iv)
-      expect(actualOptions.algorithm).toBeUndefined()
+      expect(actualOptions!.iv).toStrictEqual(iv)
+      expect(actualOptions!.algorithm).toBeUndefined()
 
       verify(
         sudoCryptoProviderMock.encryptWithSymmetricKey(
@@ -530,8 +571,8 @@ describe('DefaultSudoKeyManager', () => {
       expect(actualKey).toStrictEqual(symmetricKey)
       expect(actualData).toStrictEqual(encrypted)
       expect(actualOptions).toBeDefined()
-      expect(actualOptions.iv).toBeUndefined()
-      expect(actualOptions.algorithm).toStrictEqual(options.algorithm)
+      expect(actualOptions!.iv).toBeUndefined()
+      expect(actualOptions!.algorithm).toStrictEqual(options.algorithm)
 
       verify(
         sudoCryptoProviderMock.encryptWithSymmetricKey(
@@ -599,8 +640,8 @@ describe('DefaultSudoKeyManager', () => {
       expect(actualKeyName).toStrictEqual('VpnKey')
       expect(actualData).toStrictEqual(encrypted)
       expect(actualOptions).toBeDefined()
-      expect(actualOptions.iv).toStrictEqual(options.iv)
-      expect(actualOptions.algorithm).toBeUndefined()
+      expect(actualOptions!.iv).toStrictEqual(options.iv)
+      expect(actualOptions!.algorithm).toBeUndefined()
 
       verify(
         sudoCryptoProviderMock.decryptWithSymmetricKeyName(
@@ -638,8 +679,8 @@ describe('DefaultSudoKeyManager', () => {
       expect(actualKeyName).toStrictEqual('VpnKey')
       expect(actualData).toStrictEqual(encrypted)
       expect(actualOptions).toBeDefined()
-      expect(actualOptions.iv).toStrictEqual(options.iv)
-      expect(actualOptions.algorithm).toStrictEqual(options.algorithm)
+      expect(actualOptions!.iv).toStrictEqual(options.iv)
+      expect(actualOptions!.algorithm).toStrictEqual(options.algorithm)
 
       verify(
         sudoCryptoProviderMock.decryptWithSymmetricKeyName(
@@ -707,8 +748,8 @@ describe('DefaultSudoKeyManager', () => {
       expect(actualKey).toStrictEqual(symmetricKey)
       expect(actualData).toStrictEqual(encrypted)
       expect(actualOptions).toBeDefined()
-      expect(actualOptions.iv).toStrictEqual(iv)
-      expect(actualOptions.algorithm).toBeUndefined()
+      expect(actualOptions!.iv).toStrictEqual(iv)
+      expect(actualOptions!.algorithm).toBeUndefined()
 
       verify(
         sudoCryptoProviderMock.decryptWithSymmetricKey(
@@ -746,8 +787,8 @@ describe('DefaultSudoKeyManager', () => {
       expect(actualKey).toStrictEqual(symmetricKey)
       expect(actualData).toStrictEqual(encrypted)
       expect(actualOptions).toBeDefined()
-      expect(actualOptions.iv).toStrictEqual(iv)
-      expect(actualOptions.algorithm).toStrictEqual(options.algorithm)
+      expect(actualOptions!.iv).toStrictEqual(iv)
+      expect(actualOptions!.algorithm).toStrictEqual(options.algorithm)
 
       verify(
         sudoCryptoProviderMock.decryptWithSymmetricKey(
@@ -811,7 +852,7 @@ describe('DefaultSudoKeyManager', () => {
       expect(actualKeyName).toStrictEqual('VpnKey')
       expect(actualData).toStrictEqual(decrypted)
       expect(actualOptions).toBeDefined()
-      expect(actualOptions.algorithm).toStrictEqual(options.algorithm)
+      expect(actualOptions!.algorithm).toStrictEqual(options.algorithm)
 
       verify(
         sudoCryptoProviderMock.encryptWithPublicKey(
@@ -875,7 +916,7 @@ describe('DefaultSudoKeyManager', () => {
       expect(actualKeyName).toStrictEqual('VpnKey')
       expect(actualData).toStrictEqual(encrypted)
       expect(actualOptions).toBeDefined()
-      expect(actualOptions.algorithm).toStrictEqual(options.algorithm)
+      expect(actualOptions!.algorithm).toStrictEqual(options.algorithm)
 
       verify(
         sudoCryptoProviderMock.decryptWithPrivateKey(