Mirroristas/orbitdb
2
0
Fork 0
mirror of https://github.com/orbitdb/orbitdb.git synced 2025-03-30 15:08:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Encrypt and decrypt entries and payloads

Browse Source
This commit is contained in:
haad 2024-06-27 11:43:38 +03:00
parent 7e5672eff0
commit f30789fece
8 changed files with 326 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/database.js
View File

@ -7,7 +7,7 @@
import { EventEmitter } from 'events'
import PQueue from 'p-queue'
import Sync from './sync.js'
import { Log, Entry } from './oplog/index.js'
import { Log } from './oplog/index.js'
import { ComposedStorage, LRUStorage, IPFSBlockStorage, LevelStorage } from './storage/index.js'
import pathJoin from './utils/path-join.js'
@ -110,6 +110,8 @@ const Database = async ({ ipfs, identity, address, name, access, directory, meta
await LevelStorage({ path: pathJoin(directory, '/log/_index/') })
)
encryption = encryption || {}
const log = await Log(identity, { logId: address, access, entryStorage, headsStorage, indexStorage, encryption })
const events = new EventEmitter()
@ -140,17 +142,20 @@ const Database = async ({ ipfs, identity, address, name, access, directory, meta
return hash
}
const applyOperation = async (bytes) => {
const applyOperation = async (entry) => {
const task = async () => {
const entry = await Entry.decode(bytes)
if (entry) {
const updated = await log.joinEntry(entry)
if (updated) {
if (onUpdate) {
await onUpdate(log, entry)
try {
if (entry) {
const updated = await log.joinEntry(entry)
if (updated) {
if (onUpdate) {
await onUpdate(log, entry)
}
events.emit('update', entry)
}
events.emit('update', entry)
}
} catch (e) {
console.error(e)
}
}
await queue.add(task)

88
src/oplog/entry.js
View File

@ -55,7 +55,7 @@ const hashStringEncoding = base58btc
* // { payload: "hello", next: [], ... }
* @private
*/
const create = async (identity, id, payload, clock = null, next = [], refs = []) => {
const create = async (identity, id, payload, encryptPayloadFn, clock = null, next = [], refs = []) => {
if (identity == null) throw new Error('Identity is required, cannot create entry')
if (id == null) throw new Error('Entry requires an id')
if (payload == null) throw new Error('Entry requires a payload')
@ -63,9 +63,16 @@ const create = async (identity, id, payload, clock = null, next = [], refs = [])
clock = clock || Clock(identity.publicKey)
let encryptedPayload
if (encryptPayloadFn) {
const { bytes: encodedPayloadBytes } = await Block.encode({ value: payload, codec, hasher })
encryptedPayload = await encryptPayloadFn(encodedPayloadBytes)
}
const entry = {
id, // For determining a unique chain
payload, // Can be any dag-cbor encodeable data
payload: encryptedPayload || payload, // Can be any dag-cbor encodeable data
next, // Array of strings of CIDs
refs, // Array of strings of CIDs
clock, // Clock
@ -78,8 +85,10 @@ const create = async (identity, id, payload, clock = null, next = [], refs = [])
entry.key = identity.publicKey
entry.identity = identity.hash
entry.sig = signature
entry.payload = payload
entry.encryptedPayload = encryptedPayload
return encode(entry)
return entry
}
/**
@ -91,19 +100,21 @@ const create = async (identity, id, payload, clock = null, next = [], refs = [])
* @memberof module:Log~Entry
* @private
*/
const verify = async (identities, entry) => {
const verify = async (identities, entry, encryptPayloadFn) => {
if (!identities) throw new Error('Identities is required, cannot verify entry')
if (!isEntry(entry)) throw new Error('Invalid Log entry')
if (!entry.key) throw new Error("Entry doesn't have a key")
if (!entry.sig) throw new Error("Entry doesn't have a signature")
const e = Object.assign({}, entry)
const value = {
id: entry.id,
payload: entry.payload,
next: entry.next,
refs: entry.refs,
clock: entry.clock,
v: entry.v
id: e.id,
payload: e.encryptedPayload || e.payload,
next: e.next,
refs: e.refs,
clock: e.clock,
v: e.v
}
const { bytes } = await Block.encode({ value, codec, hasher })
@ -146,13 +157,35 @@ const isEqual = (a, b) => {
* @memberof module:Log~Entry
* @private
*/
const decode = async (bytes) => {
const { cid, value } = await Block.decode({ bytes, codec, hasher })
const decode = async (bytes, decryptPayloadFn, decryptEntryFn) => {
let cid
if (decryptEntryFn) {
const encryptedEntry = await Block.decode({ bytes, codec, hasher })
bytes = await decryptEntryFn(encryptedEntry.value)
cid = encryptedEntry.cid
}
const decodedEntry = await Block.decode({ bytes, codec, hasher })
const entry = decodedEntry.value
cid = cid || decodedEntry.cid
const hash = cid.toString(hashStringEncoding)
if (decryptPayloadFn) {
try {
const decryptedPayloadBytes = await decryptPayloadFn(entry.payload)
const { value: decryptedPayload } = await Block.decode({ bytes: decryptedPayloadBytes, codec, hasher })
entry.encryptedPayload = entry.payload
entry.payload = decryptedPayload
} catch (e) {
throw new Error('Could not decrypt entry')
}
}
return {
...value,
hash,
bytes
...entry,
hash
}
}
@ -163,13 +196,28 @@ const decode = async (bytes) => {
* @memberof module:Log~Entry
* @private
*/
const encode = async (entry) => {
const { cid, bytes } = await Block.encode({ value: entry, codec, hasher })
const encode = async (entry, encryptEntryFn, encryptPayloadFn) => {
const e = Object.assign({}, entry)
if (encryptPayloadFn) {
e.payload = e.encryptedPayload
}
delete e.encryptedPayload
delete e.hash
let { cid, bytes } = await Block.encode({ value: e, codec, hasher })
if (encryptEntryFn) {
bytes = await encryptEntryFn(bytes)
const encryptedEntry = await Block.encode({ value: bytes, codec, hasher })
cid = encryptedEntry.cid
bytes = encryptedEntry.bytes
}
const hash = cid.toString(hashStringEncoding)
const clock = Clock(entry.clock.id, entry.clock.time)
return {
...entry,
clock,
hash,
bytes
}

5
src/oplog/heads.js
View File

@ -9,7 +9,7 @@ import MemoryStorage from '../storage/memory.js'
const DefaultStorage = MemoryStorage
const Heads = async ({ storage, heads }) => {
const Heads = async ({ storage, heads, decryptPayloadFn, decryptEntryFn }) => {
storage = storage || await DefaultStorage()
const put = async (heads) => {
@ -31,7 +31,6 @@ const Heads = async ({ storage, heads }) => {
}
const newHeads = findHeads([...currentHeads, head])
await set(newHeads)
return newHeads
}
@ -44,7 +43,7 @@ const Heads = async ({ storage, heads }) => {
const iterator = async function * () {
const it = storage.iterator()
for await (const [, bytes] of it) {
const head = await Entry.decode(bytes)
const head = await Entry.decode(bytes, decryptPayloadFn, decryptEntryFn)
yield head
}
}

43
src/oplog/log.js
View File

@ -70,6 +70,9 @@ const Log = async (identity, { logId, logHeads, access, entryStorage, headsStora
}
// Set Log's id
const id = logId || randomId()
// Encryption of entries and payloads
encryption = encryption || {}
const { encryptPayloadFn, decryptPayloadFn, encryptEntryFn, decryptEntryFn } = encryption
// Access Controller
access = access || await DefaultAccessController()
// Oplog entry storage
@ -79,13 +82,10 @@ const Log = async (identity, { logId, logHeads, access, entryStorage, headsStora
// Heads storage
headsStorage = headsStorage || await DefaultStorage()
// Add heads to the state storage, ie. init the log state
const _heads = await Heads({ storage: headsStorage, heads: logHeads })
const _heads = await Heads({ storage: headsStorage, heads: logHeads, decryptPayloadFn, decryptEntryFn })
// Conflict-resolution sorting function
sortFn = NoZeroes(sortFn || LastWriteWins)
encryption = encryption || {}
const { encryptPayloadFn, decryptPayloadFn } = encryption
// Internal queues for processing appends and joins in their call-order
const appendQueue = new PQueue({ concurrency: 1 })
const joinQueue = new PQueue({ concurrency: 1 })
@ -138,14 +138,12 @@ const Log = async (identity, { logId, logHeads, access, entryStorage, headsStora
* @instance
*/
const get = async (hash) => {
if (!hash) {
throw new Error('hash is required')
}
const bytes = await _entries.get(hash)
if (bytes) {
const entry = await Entry.decode(bytes)
if (decryptPayloadFn) {
entry.payload = JSON.parse(await decryptPayloadFn(entry.payload))
}
const entry = await Entry.decode(bytes, decryptPayloadFn, decryptEntryFn)
return entry
}
}
@ -179,15 +177,12 @@ const Log = async (identity, { logId, logHeads, access, entryStorage, headsStora
// (skips the heads which are covered by the next field)
const refs = await getReferences(heads_, options.referencesCount + heads_.length)
if (encryptPayloadFn) {
data = await encryptPayloadFn(JSON.stringify(data))
}
// Create the entry
const entry = await Entry.create(
identity,
id,
data,
encryptPayloadFn,
tickClock(await clock()),
nexts,
refs
@ -198,14 +193,15 @@ const Log = async (identity, { logId, logHeads, access, entryStorage, headsStora
throw new Error(`Could not append entry:\nKey "${identity.hash}" is not allowed to write to the log`)
}
const { hash, bytes } = await Entry.encode(entry, encryptEntryFn, encryptPayloadFn)
// The appended entry is now the latest head
await _heads.set([entry])
await _heads.set([{ hash, bytes, next: entry.next }])
// Add entry to the entry storage
await _entries.put(entry.hash, entry.bytes)
await _entries.put(hash, bytes)
// Add entry to the entry index
await _index.put(entry.hash, true)
await _index.put(hash, true)
// Return the appended entry
return entry
return { ...entry, hash }
}
return appendQueue.add(task)
@ -272,7 +268,7 @@ const Log = async (identity, { logId, logHeads, access, entryStorage, headsStora
throw new Error(`Could not append entry:\nKey "${entry.identity}" is not allowed to write to the log`)
}
// Verify signature for the entry
const isValid = await Entry.verify(identity, entry)
const isValid = await Entry.verify(identity, entry, encryptPayloadFn)
if (!isValid) {
throw new Error(`Could not validate signature for entry "${entry.hash}"`)
}
@ -325,9 +321,11 @@ const Log = async (identity, { logId, logHeads, access, entryStorage, headsStora
for (const hash of connectedHeads.values()) {
await _heads.remove(hash)
}
/* 6. Add the new entry to heads (=union with current heads) */
await _heads.add(entry)
const { hash, next } = entry
const bytes = await _entries.get(hash)
await _heads.add({ hash, bytes, next })
// await _heads.add(entry)
return true
}
@ -581,7 +579,8 @@ const Log = async (identity, { logId, logHeads, access, entryStorage, headsStora
close,
access,
identity,
storage: _entries
storage: _entries,
encryption
}
}

9
src/sync.js
View File

@ -3,6 +3,7 @@ import PQueue from 'p-queue'
import { EventEmitter } from 'events'
import { TimeoutController } from 'timeout-abort-controller'
import pathJoin from './utils/path-join.js'
import { Entry } from './oplog/index.js'
const DefaultTimeout = 30000 // 30 seconds
@ -220,7 +221,8 @@ const Sync = async ({ ipfs, log, events, onSynced, start, timeout }) => {
const task = async () => {
try {
if (data && onSynced) {
await onSynced(data)
const entry = await Entry.decode(data, log.encryption.decryptPayloadFn, log.encryption.decryptEntryFn)
await onSynced(entry)
}
} catch (e) {
events.emit('error', e)
@ -240,8 +242,9 @@ const Sync = async ({ ipfs, log, events, onSynced, start, timeout }) => {
* @instance
*/
const add = async (entry) => {
if (started) {
await pubsub.publish(address, entry.bytes)
if (started && entry && entry.hash) {
const bytes = await log.storage.get(entry.hash)
await pubsub.publish(address, bytes)
}
}

24
test/oplog/log.test.js
View File

@ -144,28 +144,28 @@ describe('Log', function () {
strictEqual(values[2].payload, 'hello3')
})
it('encrypts a log entry when the payload is a string', async () => {
const keys = await keystore.createKey('hello1')
it.skip('encrypts a log entry when the payload is a string', async () => {
// const keys = await keystore.createKey('hello1')
const privateKey = await keystore.getKey('hello1')
const publicKey = await keystore.getPublic(keys)
// const privateKey = await keystore.getKey('hello1')
// const publicKey = await keystore.getPublic(keys)
const encryptPayloadFn = encrypt({ publicKey })
const decryptPayloadFn = decrypt({ privateKey })
const encryptPayloadFn = encrypt({ password: 'hello world' })
const decryptPayloadFn = decrypt({ password: 'hello world' })
const log = await Log(testIdentity, { encryption: { encryptPayloadFn, decryptPayloadFn } })
const entry = await log.append('hello1')
const value = await log.get(entry.hash)
strictEqual(value.payload, 'hello1')
})
it('encrypts a log entry when the payload is an object', async () => {
const keys = await keystore.createKey('hello1')
it.skip('encrypts a log entry when the payload is an object', async () => {
// const keys = await keystore.createKey('hello1')
const privateKey = await keystore.getKey('hello1')
const publicKey = await keystore.getPublic(keys)
// const privateKey = await keystore.getKey('hello1')
// const publicKey = await keystore.getPublic(keys)
const encryptPayloadFn = encrypt({ publicKey })
const decryptPayloadFn = decrypt({ privateKey })
const encryptPayloadFn = encrypt({ password: 'hello world' })
const decryptPayloadFn = decrypt({ password: 'hello world' })
const log = await Log(testIdentity, { encryption: { encryptPayloadFn, decryptPayloadFn } })
const entry = await log.append({ test: 'hello1' })
const value = await log.get(entry.hash)

107
test/orbitdb-encryption.test.js
View File

@ -4,26 +4,32 @@ import path from 'path'
import OrbitDB from '../src/orbitdb.js'
// import waitFor from './utils/wait-for.js'
import connectPeers from './utils/connect-nodes.js'
import waitFor from './utils/wait-for.js'
// import IPFSAccessController from '../src/access-controllers/ipfs.js'
// import OrbitDBAccessController from '../src/access-controllers/orbitdb.js'
import createHelia from './utils/create-helia.js'
import { encrypt, decrypt } from './utils/encrypt.js'
import { encrypt, decrypt, generatePassword } from './utils/encrypt.js'
const dbPath = './orbitdb/tests/write-permissions'
describe('Encryption/Decryption', function () {
this.timeout(20000)
describe.only('Encryption/Decryption', function () {
this.timeout(5000)
let ipfs1, ipfs2
let orbitdb1, orbitdb2
let db1 /*, db2 */
let db1, db2
let encryptionPassword
before(async () => {
[ipfs1, ipfs2] = await Promise.all([createHelia(), createHelia()])
await connectPeers(ipfs1, ipfs2)
await rimraf('./orbitdb')
orbitdb1 = await OrbitDB({ ipfs: ipfs1, id: 'user1', directory: path.join(dbPath, '1') })
orbitdb2 = await OrbitDB({ ipfs: ipfs2, id: 'user2', directory: path.join(dbPath, '2') })
encryptionPassword = await generatePassword()
})
after(async () => {
@ -51,38 +57,87 @@ describe('Encryption/Decryption', function () {
afterEach(async () => {
await db1.drop()
await db1.close()
// await db2.drop()
// await db2.close()
await db2.drop()
await db2.close()
})
it('encrypts/decrypts data', async () => {
const keystore = orbitdb1.keystore
const keys = await keystore.createKey('encryption-test')
it.skip('encrypts/decrypts payload', async () => {
const encryptPayloadFn = encrypt({ password: encryptionPassword })
const decryptPayloadFn = decrypt({ password: encryptionPassword })
const privateKey = await keystore.getKey('encryption-test')
const publicKey = await keystore.getPublic(keys)
const encryptFn = encrypt({ publicKey })
const decryptFn = decrypt({ privateKey })
db1 = await orbitdb1.open('encryption-test-1', { encrypt: { data: { encryptFn, decryptFn } } })
db1 = await orbitdb1.open('encryption-test-1', { encryption: { encryptPayloadFn, decryptPayloadFn } })
const hash = await db1.add('record 1')
for await (const e of db1.log.iterator()) {
console.log('>', e)
}
strictEqual(await db1.get(hash), 'record 1')
})
it('encrypts/decrypts op', async () => {
const keystore = orbitdb1.keystore
const keys = await keystore.createKey('encryption-test')
it.only('encrypts/decrypts entry', async () => {
let connected = false
let updated = false
let error = false
const privateKey = await keystore.getKey('encryption-test')
const publicKey = await keystore.getPublic(keys)
const encryptPayloadFn = encrypt({ password: encryptionPassword })
const decryptPayloadFn = decrypt({ password: encryptionPassword })
const encryptFn = encrypt({ publicKey })
const decryptFn = decrypt({ privateKey })
db1 = await orbitdb1.open('encryption-test-1', { encrypt: { op: { encryptFn, decryptFn } } })
const encryptEntryFn = encrypt({ password: encryptionPassword })
const decryptEntryFn = decrypt({ password: encryptionPassword })
const hash = await db1.add('record 1')
strictEqual(await db1.get(hash), 'record 1')
// const decryptPayloadFn2 = encrypt({ password: encryptionPassword + '1' })
// const decryptEntryFn2 = decrypt({ password: encryptionPassword + '2' })
db1 = await orbitdb1.open('encryption-test-1', { encryption: { encryptEntryFn, decryptEntryFn, encryptPayloadFn, decryptPayloadFn } })
db2 = await orbitdb2.open(db1.address, { encryption: { encryptEntryFn, decryptEntryFn, encryptPayloadFn, decryptPayloadFn } })
// db1 = await orbitdb1.open('encryption-test-1', { encryption: { encryptEntryFn, decryptEntryFn } })
// db2 = await orbitdb2.open(db1.address, { encryption: { encryptEntryFn, decryptEntryFn } })
// db1 = await orbitdb1.open('encryption-test-1', { encryption: { encryptPayloadFn, decryptPayloadFn } })
// db2 = await orbitdb2.open(db1.address, { encryption: { encryptPayloadFn, decryptPayloadFn } })
// db1 = await orbitdb1.open('encryption-test-1')
// db2 = await orbitdb2.open(db1.address)
console.log('connect')
const onJoin = async (peerId, heads) => {
console.log('connected')
connected = true
}
db2.events.on('join', onJoin)
await waitFor(() => connected, () => true)
const onUpdate = async (peerId, heads) => {
console.log('updated')
updated = true
}
db2.events.on('update', onUpdate)
const onError = async (err) => {
// Catch "Could not decrypt entry" errors
console.log(err)
error = true
}
db2.events.on('error', onError)
console.log('write')
const hash1 = await db1.add('record 1')
console.log('hash1', hash1)
const hash2 = await db1.add('record 2')
console.log('hash2', hash2)
strictEqual(await db1.get(hash1), 'record 1')
strictEqual(await db1.get(hash2), 'record 2')
await waitFor(() => updated || error, () => true)
const all = await db2.all()
console.log('all', all)
strictEqual(all.length, 2)
strictEqual(all[0].value, 'record 1')
strictEqual(all[1].value, 'record 2')
})
})

132
test/utils/encrypt.js
View File

@ -1,19 +1,131 @@
import EthCrypto from 'eth-crypto'
import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
import crypto from 'crypto'
const encrypt = ({ publicKey }) => async (value) => {
const encryptedObj = await EthCrypto.encryptWithPublicKey(publicKey, value)
return EthCrypto.cipher.stringify(encryptedObj)
// From:
// https://github.com/libp2p/js-libp2p/blob/0b55625d146940994a306101650a55ee58e32f6c/packages/crypto/src/ciphers/aes-gcm.browser.ts
import { concat } from 'uint8arrays/concat'
import { fromString } from 'uint8arrays/from-string'
// import { create } from '@libp2p/crypto/ciphers/aes-gcm'
/*
Sources:
- https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto
- https://github.com/bradyjoslin/webcrypto-example/blob/master/script.js
- https://github.com/mdn/dom-examples/blob/main/web-crypto/encrypt-decrypt/aes-gcm.js
- https://github.com/libp2p/js-libp2p/blob/0b55625d146940994a306101650a55ee58e32f6c/packages/crypto/src/ciphers/aes-gcm.browser.ts
*/
const cipher = createAes()
const encrypt = ({ password }) => async (value) => {
return cipher.encrypt(value, password)
}
const decrypt = ({ privateKey }) => async (value) => {
const privateKeyStr = uint8ArrayToString(privateKey.marshal(), 'base16')
const decrypt = ({ password }) => async (value) => {
return cipher.decrypt(value, password)
}
const encryptedObj = EthCrypto.cipher.parse(value)
return await EthCrypto.decryptWithPrivateKey(privateKeyStr, encryptedObj)
const generatePassword = async (length = 256) => {
return crypto.getRandomValues(new Uint8Array(length))
}
export {
encrypt,
decrypt
decrypt,
generatePassword
}
// import webcrypto from '../webcrypto.js';
// WebKit on Linux does not support deriving a key from an empty PBKDF2 key.
// So, as a workaround, we provide the generated key as a constant. We test that
// this generated key is accurate in test/workaround.spec.ts
// Generated via:
// await crypto.subtle.exportKey('jwk',
// await crypto.subtle.deriveKey(
// { name: 'PBKDF2', salt: new Uint8Array(16), iterations: 32767, hash: { name: 'SHA-256' } },
// await crypto.subtle.importKey('raw', new Uint8Array(0), { name: 'PBKDF2' }, false, ['deriveKey']),
// { name: 'AES-GCM', length: 128 }, true, ['encrypt', 'decrypt'])
// )
export const derivedEmptyPasswordKey = { alg: 'A128GCM', ext: true, k: 'scm9jmO_4BJAgdwWGVulLg', key_ops: ['encrypt', 'decrypt'], kty: 'oct' }
// Based off of code from https://github.com/luke-park/SecureCompatibleEncryptionExamples
export function createAes (opts) {
const algorithm = opts?.algorithm ?? 'AES-GCM'
let keyLength = opts?.keyLength ?? 16
const nonceLength = opts?.nonceLength ?? 12
const digest = opts?.digest ?? 'SHA-256'
const saltLength = opts?.saltLength ?? 16
const iterations = opts?.iterations ?? 32767
// const crypto = webcrypto.get();
keyLength *= 8 // Browser crypto uses bits instead of bytes
/**
* Uses the provided password to derive a pbkdf2 key. The key
* will then be used to encrypt the data.
*/
async function encrypt (data, password) {
const salt = crypto.getRandomValues(new Uint8Array(saltLength))
const nonce = crypto.getRandomValues(new Uint8Array(nonceLength))
const aesGcm = { name: algorithm, iv: nonce }
if (typeof password === 'string') {
password = fromString(password)
}
let cryptoKey
if (password.length === 0) {
cryptoKey = await crypto.subtle.importKey('jwk', derivedEmptyPasswordKey, { name: 'AES-GCM' }, true, ['encrypt'])
try {
const deriveParams = { name: 'PBKDF2', salt, iterations, hash: { name: digest } }
const runtimeDerivedEmptyPassword = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey'])
cryptoKey = await crypto.subtle.deriveKey(deriveParams, runtimeDerivedEmptyPassword, { name: algorithm, length: keyLength }, true, ['encrypt'])
} catch {
cryptoKey = await crypto.subtle.importKey('jwk', derivedEmptyPasswordKey, { name: 'AES-GCM' }, true, ['encrypt'])
}
} else {
// Derive a key using PBKDF2.
const deriveParams = { name: 'PBKDF2', salt, iterations, hash: { name: digest } }
const rawKey = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey'])
cryptoKey = await crypto.subtle.deriveKey(deriveParams, rawKey, { name: algorithm, length: keyLength }, true, ['encrypt'])
}
// Encrypt the string.
const ciphertext = await crypto.subtle.encrypt(aesGcm, cryptoKey, data)
return concat([salt, aesGcm.iv, new Uint8Array(ciphertext)])
}
/**
* Uses the provided password to derive a pbkdf2 key. The key
* will then be used to decrypt the data. The options used to create
* this decryption cipher must be the same as those used to create
* the encryption cipher.
*/
async function decrypt (data, password) {
const salt = data.subarray(0, saltLength)
const nonce = data.subarray(saltLength, saltLength + nonceLength)
const ciphertext = data.subarray(saltLength + nonceLength)
const aesGcm = { name: algorithm, iv: nonce }
if (typeof password === 'string') {
password = fromString(password)
}
let cryptoKey
if (password.length === 0) {
try {
const deriveParams = { name: 'PBKDF2', salt, iterations, hash: { name: digest } }
const runtimeDerivedEmptyPassword = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey'])
cryptoKey = await crypto.subtle.deriveKey(deriveParams, runtimeDerivedEmptyPassword, { name: algorithm, length: keyLength }, true, ['decrypt'])
} catch {
cryptoKey = await crypto.subtle.importKey('jwk', derivedEmptyPasswordKey, { name: 'AES-GCM' }, true, ['decrypt'])
}
} else {
// Derive the key using PBKDF2.
const deriveParams = { name: 'PBKDF2', salt, iterations, hash: { name: digest } }
const rawKey = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey'])
cryptoKey = await crypto.subtle.deriveKey(deriveParams, rawKey, { name: algorithm, length: keyLength }, true, ['decrypt'])
}
// Decrypt the string.
const plaintext = await crypto.subtle.decrypt(aesGcm, cryptoKey, ciphertext)
return new Uint8Array(plaintext)
}
const cipher = {
encrypt,
decrypt
}
return cipher
}