@libp2p/crypto 5.1.4 → 5.1.5

package/src/keys/rsa/index.ts

@@ -1,10 +1,11 @@
-import crypto from 'crypto'
-import { promisify } from 'util'
+import crypto from 'node:crypto'
+import { promisify } from 'node:util'
 import { InvalidParametersError } from '@libp2p/interface'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import randomBytes from '../../random-bytes.js'
 import * as utils from './utils.js'
 import type { JWKKeyPair } from '../interface.js'
+import type { AbortOptions } from '@libp2p/interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 const keypair = promisify(crypto.generateKeyPair)
@@ -13,13 +14,14 @@ export const RSAES_PKCS1_V1_5_OID = '1.2.840.113549.1.1.1'
 
 export { utils }
 
-export async function generateRSAKey (bits: number): Promise<JWKKeyPair> {
+export async function generateRSAKey (bits: number, options?: AbortOptions): Promise<JWKKeyPair> {
   // @ts-expect-error node types are missing jwk as a format
   const key = await keypair('rsa', {
     modulusLength: bits,
     publicKeyEncoding: { type: 'pkcs1', format: 'jwk' },
     privateKeyEncoding: { type: 'pkcs1', format: 'jwk' }
   })
+  options?.signal?.throwIfAborted()
 
   return {
     // @ts-expect-error node types are missing jwk as a format
@@ -31,7 +33,9 @@ export async function generateRSAKey (bits: number): Promise<JWKKeyPair> {
 
 export { randomBytes as getRandomValues }
 
-export async function hashAndSign (key: JsonWebKey, msg: Uint8Array | Uint8ArrayList): Promise<Uint8Array> {
+export function hashAndSign (key: JsonWebKey, msg: Uint8Array | Uint8ArrayList, options?: AbortOptions): Uint8Array {
+  options?.signal?.throwIfAborted()
+
   const hash = crypto.createSign('RSA-SHA256')
 
   if (msg instanceof Uint8Array) {
@@ -46,7 +50,9 @@ export async function hashAndSign (key: JsonWebKey, msg: Uint8Array | Uint8Array
   return hash.sign({ format: 'jwk', key })
 }
 
-export async function hashAndVerify (key: JsonWebKey, sig: Uint8Array, msg: Uint8Array | Uint8ArrayList): Promise<boolean> {
+export function hashAndVerify (key: JsonWebKey, sig: Uint8Array, msg: Uint8Array | Uint8ArrayList, options?: AbortOptions): boolean {
+  options?.signal?.throwIfAborted()
+
   const hash = crypto.createVerify('RSA-SHA256')
 
   if (msg instanceof Uint8Array) {

package/src/keys/rsa/rsa.ts

@@ -2,7 +2,7 @@ import { base58btc } from 'multiformats/bases/base58'
 import { CID } from 'multiformats/cid'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { hashAndSign, utils, hashAndVerify } from './index.js'
-import type { RSAPublicKey as RSAPublicKeyInterface, RSAPrivateKey as RSAPrivateKeyInterface } from '@libp2p/interface'
+import type { RSAPublicKey as RSAPublicKeyInterface, RSAPrivateKey as RSAPrivateKeyInterface, AbortOptions } from '@libp2p/interface'
 import type { Digest } from 'multiformats/hashes/digest'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
@@ -45,8 +45,8 @@ export class RSAPublicKey implements RSAPublicKeyInterface {
     return uint8ArrayEquals(this.raw, key.raw)
   }
 
-  verify (data: Uint8Array | Uint8ArrayList, sig: Uint8Array): boolean | Promise<boolean> {
-    return hashAndVerify(this.jwk, sig, data)
+  verify (data: Uint8Array | Uint8ArrayList, sig: Uint8Array, options?: AbortOptions): boolean | Promise<boolean> {
+    return hashAndVerify(this.jwk, sig, data, options)
   }
 }
 
@@ -77,7 +77,7 @@ export class RSAPrivateKey implements RSAPrivateKeyInterface {
     return uint8ArrayEquals(this.raw, key.raw)
   }
 
-  sign (message: Uint8Array | Uint8ArrayList): Uint8Array | Promise<Uint8Array> {
-    return hashAndSign(this.jwk, message)
+  sign (message: Uint8Array | Uint8ArrayList, options?: AbortOptions): Uint8Array | Promise<Uint8Array> {
+    return hashAndSign(this.jwk, message, options)
   }
 }

package/src/keys/secp256k1/index.browser.ts

@@ -2,6 +2,7 @@ import { secp256k1 as secp } from '@noble/curves/secp256k1'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { SigningError, VerificationError } from '../../errors.js'
 import { isPromise } from '../../util.js'
+import type { AbortOptions } from '@libp2p/interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 const PUBLIC_KEY_BYTE_LENGTH = 33
@@ -13,12 +14,20 @@ export { PRIVATE_KEY_BYTE_LENGTH as privateKeyLength }
 /**
  * Hash and sign message with private key
  */
-export function hashAndSign (key: Uint8Array, msg: Uint8Array | Uint8ArrayList): Uint8Array | Promise<Uint8Array> {
+export function hashAndSign (key: Uint8Array, msg: Uint8Array | Uint8ArrayList, options?: AbortOptions): Uint8Array | Promise<Uint8Array> {
   const p = sha256.digest(msg instanceof Uint8Array ? msg : msg.subarray())
 
   if (isPromise(p)) {
-    return p.then(({ digest }) => secp.sign(digest, key).toDERRawBytes())
+    return p
+      .then(({ digest }) => {
+        options?.signal?.throwIfAborted()
+        return secp.sign(digest, key).toDERRawBytes()
+      })
       .catch(err => {
+        if (err.name === 'AbortError') {
+          throw err
+        }
+
         throw new SigningError(String(err))
       })
   }
@@ -33,17 +42,26 @@ export function hashAndSign (key: Uint8Array, msg: Uint8Array | Uint8ArrayList):
 /**
  * Hash message and verify signature with public key
  */
-export function hashAndVerify (key: Uint8Array, sig: Uint8Array, msg: Uint8Array | Uint8ArrayList): boolean | Promise<boolean> {
+export function hashAndVerify (key: Uint8Array, sig: Uint8Array, msg: Uint8Array | Uint8ArrayList, options?: AbortOptions): boolean | Promise<boolean> {
   const p = sha256.digest(msg instanceof Uint8Array ? msg : msg.subarray())
 
   if (isPromise(p)) {
-    return p.then(({ digest }) => secp.verify(sig, digest, key))
+    return p
+      .then(({ digest }) => {
+        options?.signal?.throwIfAborted()
+        return secp.verify(sig, digest, key)
+      })
       .catch(err => {
+        if (err.name === 'AbortError') {
+          throw err
+        }
+
         throw new VerificationError(String(err))
       })
   }
 
   try {
+    options?.signal?.throwIfAborted()
     return secp.verify(sig, p.digest, key)
   } catch (err) {
     throw new VerificationError(String(err))

package/src/keys/secp256k1/index.ts

@@ -1,6 +1,7 @@
 import crypto from 'node:crypto'
 import { secp256k1 as secp } from '@noble/curves/secp256k1'
 import { SigningError, VerificationError } from '../../errors.js'
+import type { AbortOptions } from '@libp2p/interface'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 const PUBLIC_KEY_BYTE_LENGTH = 33
@@ -12,7 +13,9 @@ export { PRIVATE_KEY_BYTE_LENGTH as privateKeyLength }
 /**
  * Hash and sign message with private key
  */
-export function hashAndSign (key: Uint8Array, msg: Uint8Array | Uint8ArrayList): Uint8Array {
+export function hashAndSign (key: Uint8Array, msg: Uint8Array | Uint8ArrayList, options?: AbortOptions): Uint8Array {
+  options?.signal?.throwIfAborted()
+
   const hash = crypto.createHash('sha256')
 
   if (msg instanceof Uint8Array) {
@@ -36,7 +39,8 @@ export function hashAndSign (key: Uint8Array, msg: Uint8Array | Uint8ArrayList):
 /**
  * Hash message and verify signature with public key
  */
-export function hashAndVerify (key: Uint8Array, sig: Uint8Array, msg: Uint8Array | Uint8ArrayList): boolean {
+export function hashAndVerify (key: Uint8Array, sig: Uint8Array, msg: Uint8Array | Uint8ArrayList, options?: AbortOptions): boolean {
+  options?.signal?.throwIfAborted()
   const hash = crypto.createHash('sha256')
 
   if (msg instanceof Uint8Array) {

package/src/keys/secp256k1/secp256k1.ts

@@ -5,7 +5,7 @@ import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { publicKeyToProtobuf } from '../index.js'
 import { validateSecp256k1PublicKey, compressSecp256k1PublicKey, computeSecp256k1PublicKey, validateSecp256k1PrivateKey } from './utils.js'
 import { hashAndVerify, hashAndSign } from './index.js'
-import type { Secp256k1PublicKey as Secp256k1PublicKeyInterface, Secp256k1PrivateKey as Secp256k1PrivateKeyInterface } from '@libp2p/interface'
+import type { Secp256k1PublicKey as Secp256k1PublicKeyInterface, Secp256k1PrivateKey as Secp256k1PrivateKeyInterface, AbortOptions } from '@libp2p/interface'
 import type { Digest } from 'multiformats/hashes/digest'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
@@ -39,8 +39,8 @@ export class Secp256k1PublicKey implements Secp256k1PublicKeyInterface {
     return uint8ArrayEquals(this.raw, key.raw)
   }
 
-  verify (data: Uint8Array | Uint8ArrayList, sig: Uint8Array): boolean {
-    return hashAndVerify(this._key, sig, data)
+  verify (data: Uint8Array | Uint8ArrayList, sig: Uint8Array, options?: AbortOptions): boolean {
+    return hashAndVerify(this._key, sig, data, options)
   }
 }
 
@@ -62,7 +62,7 @@ export class Secp256k1PrivateKey implements Secp256k1PrivateKeyInterface {
     return uint8ArrayEquals(this.raw, key.raw)
   }
 
-  sign (message: Uint8Array | Uint8ArrayList): Uint8Array | Promise<Uint8Array> {
-    return hashAndSign(this.raw, message)
+  sign (message: Uint8Array | Uint8ArrayList, options?: AbortOptions): Uint8Array | Promise<Uint8Array> {
+    return hashAndSign(this.raw, message, options)
   }
 }