diff --git a/src/PolykeyAgent.ts b/src/PolykeyAgent.ts index ed2bda00d..6f2ad2994 100644 --- a/src/PolykeyAgent.ts +++ b/src/PolykeyAgent.ts @@ -1,4 +1,5 @@ import type { FileSystem } from './types'; +import type { PolykeyWorkerManagerInterface } from './workers/types'; import type { Host, Port } from './network/types'; import path from 'path'; @@ -17,7 +18,6 @@ import { Sigchain } from './sigchain'; import { ACL } from './acl'; import { DB } from '@matrixai/db'; import { Discovery } from './discovery'; -import { WorkerManager } from './workers'; import { SessionManager } from './sessions'; import { certNodeId } from './network/utils'; import { IdentitiesManager } from './identities'; @@ -30,6 +30,7 @@ import { GithubProvider } from './identities/providers'; import config from './config'; import { ErrorStateVersionMismatch } from './errors'; import { CreateDestroyStartStop } from '@matrixai/async-init/dist/CreateDestroyStartStop'; +import { createWorkerManager } from './workers/utils'; interface Polykey extends CreateDestroyStartStop {} @CreateDestroyStartStop( @@ -46,7 +47,7 @@ class Polykey { public readonly gestalts: GestaltGraph; public readonly identities: IdentitiesManager; public readonly notifications: NotificationsManager; - public readonly workers?: WorkerManager; + public readonly workers?: PolykeyWorkerManagerInterface; public readonly sigchain: Sigchain; public readonly acl: ACL; public readonly db: DB; @@ -111,7 +112,7 @@ class Polykey { notificationsManager?: NotificationsManager; acl?: ACL; db?: DB; - workerManager?: WorkerManager | null; + workerManager?: PolykeyWorkerManagerInterface | null; clientGrpcHost?: string; agentGrpcHost?: string; clientGrpcPort?: number; @@ -193,12 +194,12 @@ class Polykey { // Writing current version info. await fs_.promises.writeFile(versionFilePath, JSON.stringify(config)); - let workers_: WorkerManager | undefined = undefined; + let workers_: PolykeyWorkerManagerInterface | undefined = undefined; if (workerManager !== null) { logger_.info('Creating a WorkerManager'); workers_ = workerManager ?? - (await WorkerManager.createPolykeyWorkerManager({ + (await createWorkerManager({ cores, logger: logger_.getChild('WorkerManager'), })); @@ -298,7 +299,11 @@ class Polykey { fs: fs_, logger: logger_.getChild('VaultManager'), })); - // Vaults_.setWorkerManager(workers_); FIXME, need to be able to set this. + // Setting the workerManager for vaults. + if (workers_ != null) { + logger_.info('Setting workerManager for vaults'); + vaults_.setWorkerManager(workers_); + } const identities_ = identitiesManager ?? (await IdentitiesManager.createIdentitiesManager({ @@ -400,7 +405,7 @@ class Polykey { notificationsManager: NotificationsManager; acl: ACL; db: DB; - workerManager?: WorkerManager; + workerManager?: PolykeyWorkerManagerInterface; clientGrpcHost: string; agentGrpcHost: string; clientGrpcPort: number; @@ -583,12 +588,14 @@ class Polykey { await this.revProxy.stop(); await this.fwdProxy.stop(); await this.db.stop(); - this.keys.unsetWorkerManager(); this.logger.info('Stopped Polykey'); } public async destroy() { this.logger.info('Destroying Polykey'); + this.keys.unsetWorkerManager(); + this.db.unsetWorkerManager(); + this.vaults.unsetWorkerManager(); await this.agentGrpcServer.destroy(); await this.clientGrpcServer.destroy(); await this.sessions.destroy(); diff --git a/src/errors.ts b/src/errors.ts index 5fb435d7b..f878b93ee 100644 --- a/src/errors.ts +++ b/src/errors.ts @@ -67,6 +67,5 @@ export * from './network/errors'; export * from './nodes/errors'; export * from './claims/errors'; export * from './sigchain/errors'; -export * from './workers/errors'; export * from './bootstrap/errors'; export * from './notifications/errors'; diff --git a/src/keys/KeyManager.ts b/src/keys/KeyManager.ts index 6f3e31b14..9caeee863 100644 --- a/src/keys/KeyManager.ts +++ b/src/keys/KeyManager.ts @@ -6,8 +6,8 @@ import type { CertificatePemChain, } from './types'; import type { FileSystem } from '../types'; -import type { WorkerManager } from '../workers'; import type { NodeId } from '../nodes/types'; +import type { PolykeyWorkerManagerInterface } from '../workers/types'; import path from 'path'; import Logger from '@matrixai/logger'; @@ -38,7 +38,7 @@ class KeyManager { protected _dbKey: Buffer; protected _vaultKey: Buffer; protected rootCert: Certificate; - protected workerManager?: WorkerManager; + protected workerManager?: PolykeyWorkerManagerInterface; static async createKeyManager({ keysPath, @@ -93,7 +93,7 @@ class KeyManager { this.vaultKeyPath = path.join(keysPath, 'vault.key'); } - public setWorkerManager(workerManager: WorkerManager) { + public setWorkerManager(workerManager: PolykeyWorkerManagerInterface) { this.workerManager = workerManager; } diff --git a/src/notifications/NotificationsManager.ts b/src/notifications/NotificationsManager.ts index e29d99189..6d320542b 100644 --- a/src/notifications/NotificationsManager.ts +++ b/src/notifications/NotificationsManager.ts @@ -9,7 +9,6 @@ import type { DB, DBLevel } from '@matrixai/db'; import type { KeyManager } from '../keys'; import type { NodeManager } from '../nodes'; import type { NodeId } from '../nodes/types'; -import type { WorkerManager } from '../workers'; import Logger from '@matrixai/logger'; import { Mutex } from 'async-mutex'; @@ -34,7 +33,6 @@ class NotificationsManager { protected db: DB; protected keyManager: KeyManager; protected nodeManager: NodeManager; - protected workerManager?: WorkerManager; protected messageCap: number; diff --git a/src/types.ts b/src/types.ts index 5dec27c4d..33e3a5a6e 100644 --- a/src/types.ts +++ b/src/types.ts @@ -11,13 +11,6 @@ type POJO = { [key: string]: any }; */ type Opaque = T & { __TYPE__: K }; -/** - * Any type that can be turned into a string - */ -interface ToString { - toString(): string; -} - /** * Allows extension of constructors that use POJOs */ @@ -25,6 +18,18 @@ type AbstractConstructorParameters = ConstructorParameters< (new (...args: any) => any) & T >; +type Initial = T extends [...infer Head, any] ? Head : any[]; +type InitialParameters any> = Initial< + Parameters +>; + +/** + * Any type that can be turned into a string + */ +interface ToString { + toString(): string; +} + /** * Wrap a type to be reference counted * Useful for when we need to garbage collect data @@ -69,20 +74,15 @@ type LockConfig = { clientPort?: number | undefined; } & POJO; -type Initial = T extends [...infer Head, any] ? Head : any[]; -type InitialParameters any> = Initial< - Parameters ->; - export { POJO, Opaque, - ToString, AbstractConstructorParameters, + Initial, + InitialParameters, + ToString, Ref, Timer, FileSystem, LockConfig, - Initial, - InitialParameters, }; diff --git a/src/vaults/VaultManager.ts b/src/vaults/VaultManager.ts index 211d49a6e..e5bf2ea6e 100644 --- a/src/vaults/VaultManager.ts +++ b/src/vaults/VaultManager.ts @@ -8,8 +8,8 @@ import type { Vault, } from './types'; import type { FileSystem } from '../types'; -import type { WorkerManager } from '../workers'; import type { NodeId } from '../nodes/types'; +import type { PolykeyWorkerManagerInterface } from '../workers/types'; import path from 'path'; import Logger from '@matrixai/logger'; @@ -50,7 +50,6 @@ class VaultManager { protected efs: EncryptedFS; protected db: DB; protected logger: Logger; - protected workerManager?: WorkerManager; protected vaultsKey: VaultKey; protected vaultsMap: VaultMap; protected vaultsDbDomain: string; @@ -167,6 +166,14 @@ class VaultManager { this.logger = logger ?? new Logger(this.constructor.name); } + public setWorkerManager(workerManager: PolykeyWorkerManagerInterface) { + this.efs.setWorkerManager(workerManager); + } + + public unsetWorkerManager() { + this.efs.unsetWorkerManager(); + } + public async transaction( f: (vaultManager: VaultManager) => Promise, lock: MutexInterface, diff --git a/src/workers/WorkerManager.ts b/src/workers/WorkerManager.ts deleted file mode 100644 index 3cfb374bf..000000000 --- a/src/workers/WorkerManager.ts +++ /dev/null @@ -1,25 +0,0 @@ -import { WorkerManager as WorkerManager_ } from '@matrixai/workers'; -import { PolykeyWorker } from './polykeyWorkerModule'; -import { spawn, Worker } from 'threads'; -import Logger from '@matrixai/logger'; - -/** - * Type alias for `WorkerManager_` - */ -class WorkerManager extends WorkerManager_ { - static createPolykeyWorkerManager({ - cores, - logger, - }: { - cores?: number; - logger?: Logger; - }): Promise { - return super.createWorkerManager({ - workerFactory: () => spawn(new Worker('./polykeyWorker.ts')), - cores, - logger, - }); - } -} - -export default WorkerManager; diff --git a/src/workers/errors.ts b/src/workers/errors.ts deleted file mode 100644 index 31649646e..000000000 --- a/src/workers/errors.ts +++ /dev/null @@ -1,7 +0,0 @@ -import { ErrorPolykey } from '../errors'; - -class ErrorWorkers extends ErrorPolykey {} - -class ErrorNotRunning extends ErrorWorkers {} - -export { ErrorWorkers, ErrorNotRunning }; diff --git a/src/workers/index.ts b/src/workers/index.ts index f8cb46d47..a6cf25ab7 100644 --- a/src/workers/index.ts +++ b/src/workers/index.ts @@ -1,3 +1,5 @@ -export { default as WorkerManager } from './WorkerManager'; export { default as polykeyWorker } from './polykeyWorkerModule'; -export * as errors from './errors'; +export * as utils from './utils'; + +export type { PolykeyWorkerModule } from './polykeyWorkerModule'; +export type { PolykeyWorkerManagerInterface } from './types'; diff --git a/src/workers/polykeyWorker.ts b/src/workers/polykeyWorker.ts index c6724027d..8bf333e30 100644 --- a/src/workers/polykeyWorker.ts +++ b/src/workers/polykeyWorker.ts @@ -1,8 +1,8 @@ -import type { PolykeyWorker } from './polykeyWorkerModule'; +import type { PolykeyWorkerModule } from './polykeyWorkerModule'; import { expose } from 'threads/worker'; import polykeyWorker from './polykeyWorkerModule'; expose(polykeyWorker); -export type { PolykeyWorker }; +export type { PolykeyWorkerModule }; diff --git a/src/workers/polykeyWorkerModule.ts b/src/workers/polykeyWorkerModule.ts index a51916523..882b95ec8 100644 --- a/src/workers/polykeyWorkerModule.ts +++ b/src/workers/polykeyWorkerModule.ts @@ -1,8 +1,8 @@ import type { TransferDescriptor } from 'threads'; import type { PublicKeyAsn1, PrivateKeyAsn1, KeyPairAsn1 } from '../keys/types'; +import { Transfer } from 'threads/worker'; import { utils as keysUtils } from '../keys'; -import { isWorkerRuntime, Transfer } from 'threads/worker'; /** * Worker object that contains all functions that will be executed in parallel @@ -32,24 +32,6 @@ const polykeyWorker = { } }, - // Normal functions - /** - * Check if we are running in the worker. - * Only used for testing - */ - isRunningInWorker(): boolean { - return isWorkerRuntime(); - }, - /** - * Sleep synchronously - * This blocks the entire event loop - * Only used for testing - */ - sleep(ms: number): void { - Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); - return; - }, - // KeyManager operations /** * Generate KeyPair @@ -93,71 +75,10 @@ const polykeyWorker = { const signed = keysUtils.verifyWithPublicKey(publicKey, data_, signature_); return signed; }, - - // These operations are "overwriting" the EFS ops - // they are using our crypto mechanisms - // during parallel execution - // unless we are injecting our own crypto mechanism in it - // so they are sharing the same system - // so it seems the proper way to do this - // would be ensure that we have a common interface for a crypto utility - // like an object containing the relevant operations - - // DB operations - /** - * Zero copy encryption of plain text to cipher text - */ - async encryptWithKey( - key: ArrayBuffer, - keyOffset: number, - keyLength: number, - plainText: ArrayBuffer, - plainTextOffset: number, - plainTextLength: number, - ): Promise> { - const key_ = Buffer.from(key, keyOffset, keyLength); - const plainText_ = Buffer.from(plainText, plainTextOffset, plainTextLength); - const cipherText = Buffer.from( - await keysUtils.encryptWithKey(key_, plainText_), - ); - return Transfer( - [cipherText.buffer, cipherText.byteOffset, cipherText.byteLength], - [cipherText.buffer], - ); - }, - /** - * Zero copy decryption of cipher text to plain text - */ - async decryptWithKey( - key: ArrayBuffer, - keyOffset: number, - keyLength: number, - cipherText: ArrayBuffer, - cipherTextOffset: number, - cipherTextLength: number, - ): Promise | undefined> { - const key_ = Buffer.from(key, keyOffset, keyLength); - const cipherText_ = Buffer.from( - cipherText, - cipherTextOffset, - cipherTextLength, - ); - const plainText = Buffer.from( - (await keysUtils.decryptWithKey(key_, cipherText_))!, - ); - if (plainText != null) { - return Transfer( - [plainText.buffer, plainText.byteOffset, plainText.byteLength], - [plainText.buffer], - ); - } else { - return; - } - }, }; -type PolykeyWorker = typeof polykeyWorker; +type PolykeyWorkerModule = typeof polykeyWorker; -export type { PolykeyWorker }; +export type { PolykeyWorkerModule }; export default polykeyWorker; diff --git a/src/workers/types.ts b/src/workers/types.ts new file mode 100644 index 000000000..293232ca3 --- /dev/null +++ b/src/workers/types.ts @@ -0,0 +1,7 @@ +import type { WorkerManagerInterface } from '@matrixai/workers'; +import type { PolykeyWorkerModule } from './polykeyWorkerModule'; + +type PolykeyWorkerManagerInterface = + WorkerManagerInterface; + +export type { PolykeyWorkerManagerInterface }; diff --git a/src/workers/utils.ts b/src/workers/utils.ts new file mode 100644 index 000000000..04c208da0 --- /dev/null +++ b/src/workers/utils.ts @@ -0,0 +1,22 @@ +import type { PolykeyWorkerModule } from './polykeyWorkerModule'; +import type { PolykeyWorkerManagerInterface } from './types'; + +import { WorkerManager } from '@matrixai/workers'; +import Logger from '@matrixai/logger'; +import { spawn, Worker } from 'threads'; + +async function createWorkerManager({ + cores, + logger, +}: { + cores?: number; + logger?: Logger; +}): Promise { + return await WorkerManager.createWorkerManager({ + workerFactory: () => spawn(new Worker('./polykeyWorker')), + cores, + logger, + }); +} + +export { createWorkerManager }; diff --git a/tests/bin/agent.test.ts b/tests/bin/agent.test.ts index e79ca2f38..6549f99ab 100644 --- a/tests/bin/agent.test.ts +++ b/tests/bin/agent.test.ts @@ -162,7 +162,7 @@ describe('CLI agent', () => { //Checking that the lockfile was removed. await poll(global.polykeyStartupTimeout * 2, async () => { - const files = await fs.promises.readdir(foregroundNodePath); + const files = await fs.promises.readdir(backgroundNodePath); const test = files.includes('agent-lock.json'); return !test; }); diff --git a/tests/keys/KeyManager.test.ts b/tests/keys/KeyManager.test.ts index 1746d98ca..11e421a92 100644 --- a/tests/keys/KeyManager.test.ts +++ b/tests/keys/KeyManager.test.ts @@ -1,4 +1,5 @@ import type { PublicKey } from '@/keys/types'; +import type { PolykeyWorkerManagerInterface } from '@/workers/types'; import fs from 'fs'; import os from 'os'; @@ -7,13 +8,13 @@ import { Buffer } from 'buffer'; import Logger, { LogLevel, StreamHandler } from '@matrixai/logger'; import KeyManager from '@/keys/KeyManager'; -import WorkerManager from '@/workers/WorkerManager'; import { DB } from '@matrixai/db'; import { sleep } from '@/utils'; import * as keysUtils from '@/keys/utils'; import * as keysErrors from '@/keys/errors'; import { makeCrypto } from '../utils'; import { isNodeId, makeNodeId } from '@/nodes/utils'; +import { createWorkerManager } from '@/workers/utils'; describe('KeyManager', () => { const password = 'password'; @@ -22,9 +23,9 @@ describe('KeyManager', () => { ]); let dataDir: string; const cores = 1; - let workerManager: WorkerManager; + let workerManager: PolykeyWorkerManagerInterface; beforeAll(async () => { - workerManager = await WorkerManager.createPolykeyWorkerManager({ + workerManager = await createWorkerManager({ cores, logger, }); diff --git a/tests/workers/WorkerManager.test.ts b/tests/workers/WorkerManager.test.ts deleted file mode 100644 index 35959367f..000000000 --- a/tests/workers/WorkerManager.test.ts +++ /dev/null @@ -1,89 +0,0 @@ -import process from 'process'; -import Logger, { LogLevel, StreamHandler } from '@matrixai/logger'; -import WorkerManager from '@/workers/WorkerManager'; -import { errors as workersErrors } from '@matrixai/workers'; - -describe('WorkerManager', () => { - const logger = new Logger('WorkerManager Test', LogLevel.WARN, [ - new StreamHandler(), - ]); - const cores = 1; - let workerManager: WorkerManager; - beforeAll(async () => { - workerManager = await WorkerManager.createPolykeyWorkerManager({ - cores, - logger, - }); - }); - afterAll(async () => { - await workerManager.destroy(); - expect(workerManager.destroyed).toBeTruthy(); - }); - test('construction has no side effects', async () => { - const tempWorker = await WorkerManager.createPolykeyWorkerManager({ - cores, - logger, - }); - await tempWorker.destroy(); - }); - test('call runs in the main thread', async () => { - const mainPid1 = process.pid; - let mainPid2; - let mainPid3; - // Only `w.f()` functions are running in the worker threads - // the callback passed to `call` is still running in the main thread - expect( - await workerManager.call(async (w) => { - mainPid2 = process.pid; - const process2 = require('process'); - mainPid3 = process2.pid; - return await w.isRunningInWorker(); - }), - ).toBe(true); - expect(mainPid2).toBe(mainPid1); - expect(mainPid3).toBe(mainPid1); - }); - test('can await a subset of tasks', async () => { - const task = workerManager.call(async (w) => { - return await w.sleep(500); - }); - const taskCount = 5; - const tasks: Array> = []; - for (let i = 0; i < taskCount; i++) { - tasks.push( - workerManager.call(async (w) => { - return await w.sleep(500); - }), - ); - } - const rs = await Promise.all(tasks); - expect(rs.length).toBe(taskCount); - expect(rs.every((x) => x === undefined)).toBe(true); - const r = await task; - expect(r).toBeUndefined(); - }); - test('queueing up tasks', async () => { - const t1 = workerManager.queue(async (w) => await w.sleep(500)); - const t2 = workerManager.queue(async (w) => await w.sleep(500)); - const t3 = workerManager.queue(async (w) => await w.sleep(500)); - const t4 = workerManager.queue(async (w) => await w.sleep(500)); - await workerManager.completed(); - expect(await t1).toBeUndefined(); - expect(await t2).toBeUndefined(); - expect(await t3).toBeUndefined(); - expect(await t4).toBeUndefined(); - workerManager.queue(async (w) => await w.sleep(500)); - workerManager.queue(async (w) => await w.sleep(500)); - workerManager.queue(async (w) => await w.sleep(500)); - workerManager.queue(async (w) => await w.sleep(500)); - const es = await workerManager.settled(); - expect(es.length).toBe(0); - }); - test('async start and async stop', async () => { - expect(await workerManager.call(async () => 1)).toBe(1); - await workerManager.destroy(); - await expect(() => workerManager.call(async () => 1)).rejects.toThrow( - workersErrors.ErrorWorkerManagerNotRunning, - ); - }); -}); diff --git a/tests/workers/polykeyWorker.test.ts b/tests/workers/polykeyWorker.test.ts new file mode 100644 index 000000000..da04b6d6a --- /dev/null +++ b/tests/workers/polykeyWorker.test.ts @@ -0,0 +1,74 @@ +import type { PolykeyWorkerManagerInterface } from '@/workers/types'; + +import Logger, { LogLevel, StreamHandler } from '@matrixai/logger'; +import { createWorkerManager } from '@/workers/utils'; + +describe('Polykey worker', () => { + const logger = new Logger('PolyKey Worker Test', LogLevel.WARN, [ + new StreamHandler(), + ]); + let workerManager: PolykeyWorkerManagerInterface; + beforeAll(async () => { + workerManager = await createWorkerManager({ + cores: 1, + logger, + }); + }); + afterAll(async () => { + await workerManager.destroy(); + }); + test('generateKeyPairAsn1', async () => { + await workerManager.call(async (w) => { + await w.generateKeyPairAsn1(4096); + }); + }); + test('encryptWithPublicKeyAsn1', async () => { + const message = 'Hello world!'; + await workerManager.call(async (w) => { + const keyPair = await w.generateKeyPairAsn1(4096); + const encrypted = w.encryptWithPublicKeyAsn1( + keyPair.privateKey, + // @ts-ignore: threads.js types are wrong + message, + ); + expect(encrypted).not.toEqual(message); + }); + }); + test('decryptWithPrivateKeyAsn1', async () => { + await workerManager.call(async (w) => { + const message = 'Hello world!'; + const keyPair = await w.generateKeyPairAsn1(4096); + const encrypted = await w.encryptWithPublicKeyAsn1( + keyPair.publicKey, + message, + ); + expect(encrypted).not.toEqual(message); + const decrypted = await w.decryptWithPrivateKeyAsn1( + keyPair.privateKey, + encrypted, + ); + expect(decrypted).toEqual(message); + }); + }); + test('signWithPrivateKeyAsn1', async () => { + await workerManager.call(async (w) => { + const message = 'Hello world!'; + const keyPair = await w.generateKeyPairAsn1(4096); + const signature = w.signWithPrivateKeyAsn1(keyPair.privateKey, message); + expect(signature).toBeTruthy(); + }); + }); + test('verifyWithPublicKeyAsn1', async () => { + await workerManager.call(async (w) => { + const message = 'Hello world!'; + const keyPair = await w.generateKeyPairAsn1(4096); + const signature = await w.signWithPrivateKeyAsn1( + keyPair.privateKey, + message, + ); + expect( + w.verifyWithPublicKeyAsn1(keyPair.publicKey, message, signature), + ).toBeTruthy(); + }); + }); +}); diff --git a/tests/workers/polykeyWorkerModule.test.ts b/tests/workers/polykeyWorkerModule.test.ts deleted file mode 100644 index 0f1100cdc..000000000 --- a/tests/workers/polykeyWorkerModule.test.ts +++ /dev/null @@ -1,68 +0,0 @@ -import { polykeyWorker } from '@/workers'; - -describe('PolykeyWorkerModule', () => { - test('isRunningInWorker', async () => { - expect(polykeyWorker.isRunningInWorker()).toBeFalsy(); - }); - test('sleep', async () => { - const delay = 500; - const startTime = new Date().getTime(); - polykeyWorker.sleep(delay); - const finishTime = new Date().getTime(); - expect(finishTime - startTime).not.toBeLessThan(delay); - }); - test('generateKeyPairAsn1', async () => { - await polykeyWorker.generateKeyPairAsn1(4096); - //Didn't throw an error, must be working... - }); - test('encryptWithPublicKeyAsn1', async () => { - const message = 'Hello world!'; - const keyPair = await polykeyWorker.generateKeyPairAsn1(4096); - const encrypted = polykeyWorker.encryptWithPublicKeyAsn1( - keyPair.publicKey, - message, - ); - expect(encrypted).not.toEqual(message); - }); - test('decryptWithPrivateKeyAsn1', async () => { - const message = 'Hello world!'; - const keyPair = await polykeyWorker.generateKeyPairAsn1(4096); - const encrypted = polykeyWorker.encryptWithPublicKeyAsn1( - keyPair.publicKey, - message, - ); - expect(encrypted).not.toEqual(message); - const decrypted = polykeyWorker.decryptWithPrivateKeyAsn1( - keyPair.privateKey, - encrypted, - ); - expect(decrypted).toEqual(message); - }); - test('signWithPrivateKeyAsn1', async () => { - const message = 'Hello world!'; - const keyPair = await polykeyWorker.generateKeyPairAsn1(4096); - const signature = polykeyWorker.signWithPrivateKeyAsn1( - keyPair.privateKey, - message, - ); - expect(signature).toBeTruthy(); - }); - test('verifyWithPublicKeyAsn1', async () => { - const message = 'Hello world!'; - const keyPair = await polykeyWorker.generateKeyPairAsn1(4096); - const signature = polykeyWorker.signWithPrivateKeyAsn1( - keyPair.privateKey, - message, - ); - expect( - polykeyWorker.verifyWithPublicKeyAsn1( - keyPair.publicKey, - message, - signature, - ), - ).toBeTruthy(); - }); - // EFS worker. - test.todo('encryptBlock'); - test.todo('decryptChunk'); -});