98 lines
3.3 KiB
JavaScript
98 lines
3.3 KiB
JavaScript
const asmcrypto = require('asmcrypto.js')
|
|
const Unibabel = require('browserify-unibabel')
|
|
|
|
/**
|
|
* A Microsoft Edge-specific encryption class that exposes
|
|
* the interface expected by eth-keykeyring-controller
|
|
*/
|
|
class EdgeEncryptor {
|
|
/**
|
|
* Encrypts an arbitrary object to ciphertext
|
|
*
|
|
* @param {string} password Used to generate a key to encrypt the data
|
|
* @param {Object} dataObject Data to encrypt
|
|
* @returns {Promise<string>} Promise resolving to an object with ciphertext
|
|
*/
|
|
encrypt (password, dataObject) {
|
|
var salt = this._generateSalt()
|
|
return this._keyFromPassword(password, salt)
|
|
.then(function (key) {
|
|
var data = JSON.stringify(dataObject)
|
|
var dataBuffer = Unibabel.utf8ToBuffer(data)
|
|
var vector = global.crypto.getRandomValues(new Uint8Array(16))
|
|
var resultbuffer = asmcrypto.AES_GCM.encrypt(dataBuffer, key, vector)
|
|
|
|
var buffer = new Uint8Array(resultbuffer)
|
|
var vectorStr = Unibabel.bufferToBase64(vector)
|
|
var vaultStr = Unibabel.bufferToBase64(buffer)
|
|
return JSON.stringify({
|
|
data: vaultStr,
|
|
iv: vectorStr,
|
|
salt: salt,
|
|
})
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Decrypts an arbitrary object from ciphertext
|
|
*
|
|
* @param {string} password Used to generate a key to decrypt the data
|
|
* @param {string} text Ciphertext of an encrypted object
|
|
* @returns {Promise<Object>} Promise resolving to copy of decrypted object
|
|
*/
|
|
decrypt (password, text) {
|
|
const payload = JSON.parse(text)
|
|
const salt = payload.salt
|
|
return this._keyFromPassword(password, salt)
|
|
.then(function (key) {
|
|
const encryptedData = Unibabel.base64ToBuffer(payload.data)
|
|
const vector = Unibabel.base64ToBuffer(payload.iv)
|
|
return new Promise((resolve, reject) => {
|
|
var result
|
|
try {
|
|
result = asmcrypto.AES_GCM.decrypt(encryptedData, key, vector)
|
|
} catch (err) {
|
|
return reject(new Error('Incorrect password'))
|
|
}
|
|
const decryptedData = new Uint8Array(result)
|
|
const decryptedStr = Unibabel.bufferToUtf8(decryptedData)
|
|
const decryptedObj = JSON.parse(decryptedStr)
|
|
resolve(decryptedObj)
|
|
})
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Retrieves a cryptographic key using a password
|
|
*
|
|
* @private
|
|
* @param {string} password Password used to unlock a cryptographic key
|
|
* @param {string} salt Random base64 data
|
|
* @returns {Promise<Object>} Promise resolving to a derived key
|
|
*/
|
|
_keyFromPassword (password, salt) {
|
|
|
|
var passBuffer = Unibabel.utf8ToBuffer(password)
|
|
var saltBuffer = Unibabel.base64ToBuffer(salt)
|
|
return new Promise((resolve) => {
|
|
var key = asmcrypto.PBKDF2_HMAC_SHA256.bytes(passBuffer, saltBuffer, 10000)
|
|
resolve(key)
|
|
})
|
|
}
|
|
|
|
/**
|
|
* Generates random base64 encoded data
|
|
*
|
|
* @private
|
|
* @returns {string} Randomized base64 encoded data
|
|
*/
|
|
_generateSalt (byteCount = 32) {
|
|
var view = new Uint8Array(byteCount)
|
|
global.crypto.getRandomValues(view)
|
|
var b64encoded = btoa(String.fromCharCode.apply(null, view))
|
|
return b64encoded
|
|
}
|
|
}
|
|
|
|
module.exports = EdgeEncryptor
|