@sudoplatform/sudo-common 6.4.0 → 7.0.2

package/github/src/sudoKeyManager/sudoCryptoProvider.ts

@@ -91,7 +91,7 @@ export interface SudoCryptoProvider {
    *
    * @param name The name of the symmetric key.
    */
-  doesSymmetricKeyExists(name: string): Promise<boolean>
+  doesSymmetricKeyExist(name: string): Promise<boolean>
 
   /**
    * Deletes a symmetric key from the secure store.
@@ -138,6 +138,36 @@ export interface SudoCryptoProvider {
    */
   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
+   *
+   * @throws {@link KeyNotFoundError}
+   */
+  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>
+
   /**
    * Adds a private key to the secure store.
    *
@@ -160,7 +190,7 @@ export interface SudoCryptoProvider {
    *
    * @param name The name of the private key.
    */
-  doesPrivateKeyExists(name: string): Promise<boolean>
+  doesPrivateKeyExist(name: string): Promise<boolean>
 
   /**
    * Adds a public key to the secure store.
@@ -170,6 +200,13 @@ export interface SudoCryptoProvider {
    */
   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.
    *
@@ -211,6 +248,7 @@ export interface SudoCryptoProvider {
    * @returns Encrypted data and IV
    *
    * @throws {@link UnrecognizedAlgorithmError}
+   * @throws {@link KeyNotFoundError}
    */
   encryptWithSymmetricKeyName(
     name: string,
@@ -244,6 +282,7 @@ export interface SudoCryptoProvider {
    * @returns Decrypted data
    *
    * @throws {@link UnrecognizedAlgorithmError}
+   * @throws {@link KeyNotFoundError}
    */
   decryptWithSymmetricKeyName(
     name: string,
@@ -326,6 +365,7 @@ export interface SudoCryptoProvider {
    * @returns Encrypted data
    *
    * @throws {@link UnrecognizedAlgorithmError}
+   * @throws {@link KeyNotFoundError}
    */
   encryptWithPublicKey(
     name: string,
@@ -339,9 +379,10 @@ export interface SudoCryptoProvider {
    * @param name The name of the private key to use for decryption.
    * @param data The data to decrypt.
    *
-   * @returns Decrypted data or undefined if the private key is not found.
+   * @returns Decrypted data.
    *
    * @throws {@link UnrecognizedAlgorithmError}
+   * @throws {@link KeyNotFoundError}
    */
   decryptWithPrivateKey(
     name: string,

package/github/src/sudoKeyManager/sudoKeyManager.ts

@@ -68,7 +68,7 @@ export interface SudoKeyManager {
    *
    * @param name The name of the symmetric key.
    */
-  doesSymmetricKeyExists(name: string): Promise<boolean>
+  doesSymmetricKeyExist(name: string): Promise<boolean>
 
   /**
    * Deletes a symmetric key from the secure store.
@@ -99,7 +99,7 @@ export interface SudoKeyManager {
    *
    * @param name The name of the private key.
    */
-  doesPrivateKeyExists(name: string): Promise<boolean>
+  doesPrivateKeyExist(name: string): Promise<boolean>
 
   /**
    * Adds a public key to the secure store.
@@ -111,6 +111,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 +136,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,8 +428,8 @@ export class DefaultSudoKeyManager implements SudoKeyManager {
     return this.sudoCryptoProvider.getSymmetricKey(name)
   }
 
-  public doesSymmetricKeyExists(name: string): Promise<boolean> {
-    return this.sudoCryptoProvider.doesSymmetricKeyExists(name)
+  public doesSymmetricKeyExist(name: string): Promise<boolean> {
+    return this.sudoCryptoProvider.doesSymmetricKeyExist(name)
   }
 
   public deleteSymmetricKey(name: string): Promise<void> {
@@ -413,14 +448,18 @@ export class DefaultSudoKeyManager implements SudoKeyManager {
     return this.sudoCryptoProvider.getPrivateKey(name)
   }
 
-  public doesPrivateKeyExists(name: string): Promise<boolean> {
-    return this.sudoCryptoProvider.doesPrivateKeyExists(name)
+  public doesPrivateKeyExist(name: string): Promise<boolean> {
+    return this.sudoCryptoProvider.doesPrivateKeyExist(name)
   }
 
   public addPublicKey(key: ArrayBuffer, name: string): Promise<void> {
     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,6 +468,25 @@ 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,

package/github/test/unit/sudoKeyManager.spec.ts

@@ -177,21 +177,21 @@ describe('DefaultSudoKeyManager', () => {
     })
   })
 
-  describe('doesSymmetricKeyExists', () => {
-    it('should call crypto provider doesSymmetricKeyExists', async () => {
+  describe('doesSymmetricKeyExist', () => {
+    it('should call crypto provider doesSymmetricKeyExist', async () => {
       when(
-        sudoCryptoProviderMock.doesSymmetricKeyExists(anything()),
+        sudoCryptoProviderMock.doesSymmetricKeyExist(anything()),
       ).thenResolve(true)
 
       await expect(
-        sudoKeyManager.doesSymmetricKeyExists('VpnKey'),
+        sudoKeyManager.doesSymmetricKeyExist('VpnKey'),
       ).resolves.toEqual(true)
       const [actualKey] = capture(
-        sudoCryptoProviderMock.doesSymmetricKeyExists,
+        sudoCryptoProviderMock.doesSymmetricKeyExist,
       ).first()
       expect(actualKey).toStrictEqual('VpnKey')
 
-      verify(sudoCryptoProviderMock.doesSymmetricKeyExists(anything())).once()
+      verify(sudoCryptoProviderMock.doesSymmetricKeyExist(anything())).once()
     })
   })
 
@@ -281,22 +281,22 @@ describe('DefaultSudoKeyManager', () => {
     })
   })
 
-  describe('doesPrivateKeyExists', () => {
-    it('should call crypto provider doesPrivateKeyExists', async () => {
-      when(sudoCryptoProviderMock.doesPrivateKeyExists(anything())).thenResolve(
+  describe('doesPrivateKeyExist', () => {
+    it('should call crypto provider doesPrivateKeyExist', async () => {
+      when(sudoCryptoProviderMock.doesPrivateKeyExist(anything())).thenResolve(
         true,
       )
 
       await expect(
-        sudoKeyManager.doesPrivateKeyExists('VpnKeyPair'),
+        sudoKeyManager.doesPrivateKeyExist('VpnKeyPair'),
       ).resolves.toBeTruthy()
 
       const [actualKeyName] = capture(
-        sudoCryptoProviderMock.doesPrivateKeyExists,
+        sudoCryptoProviderMock.doesPrivateKeyExist,
       ).first()
       expect(actualKeyName).toStrictEqual('VpnKeyPair')
 
-      verify(sudoCryptoProviderMock.doesPrivateKeyExists(anything())).once()
+      verify(sudoCryptoProviderMock.doesPrivateKeyExist(anything())).once()
     })
   })