mirror of
https://github.com/keeweb/keeweb.git
synced 2024-06-27 07:45:08 +02:00
149 lines
6.3 KiB
JavaScript
149 lines
6.3 KiB
JavaScript
const kdbxweb = require('kdbxweb');
|
|
const Logger = require('../util/logger');
|
|
|
|
const logger = new Logger('argon2');
|
|
|
|
const KdbxwebInit = {
|
|
init() {
|
|
kdbxweb.CryptoEngine.argon2 = (...args) => this.argon2(...args);
|
|
},
|
|
|
|
argon2(password, salt, memory, iterations, length, parallelism, type, version) {
|
|
const args = { password, salt, memory, iterations, length, parallelism, type, version };
|
|
return this.loadRuntime().then(runtime => {
|
|
const ts = logger.ts();
|
|
return runtime.hash(args).then(hash => {
|
|
logger.debug('Hash computed', logger.ts(ts));
|
|
return hash;
|
|
});
|
|
});
|
|
},
|
|
|
|
loadRuntime() {
|
|
if (this.runtimeModule) {
|
|
return Promise.resolve(this.runtimeModule);
|
|
}
|
|
if (!global.WebAssembly) {
|
|
return this.loadAsmJsFallbackRuntime();
|
|
}
|
|
return new Promise((resolve, reject) => {
|
|
const loadTimeout = setTimeout(() => reject('timeout'), 1000);
|
|
try {
|
|
const ts = logger.ts();
|
|
const argon2LoaderCode = require('argon2');
|
|
const wasmBinaryBase64 = require('argon2-wasm');
|
|
const moduleDecl = '{' +
|
|
'wasmJSMethod: "native-wasm",' +
|
|
'wasmBinary: Uint8Array.from(atob("' + wasmBinaryBase64 + '"), c => c.charCodeAt(0)),' +
|
|
'print(...args) { postMessage({op:"log",args}) },' +
|
|
'printErr(...args) { postMessage({op:"log",args}) },' +
|
|
'postRun:' + this.workerPostRun.toString() + ',' +
|
|
'calcHash:' + this.calcHash.toString() + ',' +
|
|
'}';
|
|
const script = argon2LoaderCode.replace('var Module', 'var Module=' + moduleDecl);
|
|
const blob = new Blob([script], {type: 'application/javascript'});
|
|
const objectUrl = URL.createObjectURL(blob);
|
|
const worker = new Worker(objectUrl);
|
|
const onMessage = e => {
|
|
switch (e.data.op) {
|
|
case 'log':
|
|
logger.debug(...e.data.args);
|
|
break;
|
|
case 'postRun':
|
|
logger.debug('WebAssembly runtime loaded', logger.ts(ts));
|
|
URL.revokeObjectURL(objectUrl);
|
|
clearTimeout(loadTimeout);
|
|
worker.removeEventListener('message', onMessage);
|
|
this.runtimeModule = {
|
|
hash(args) {
|
|
return new Promise((resolve, reject) => {
|
|
worker.postMessage(args);
|
|
const onHashMessage = e => {
|
|
worker.removeEventListener('message', onHashMessage);
|
|
if (!e.data || e.data.error || !e.data.hash) {
|
|
const ex = e.data && e.data.error || 'unexpected error';
|
|
logger.error('Worker error', ex);
|
|
reject(ex);
|
|
}
|
|
resolve(e.data.hash);
|
|
};
|
|
worker.addEventListener('message', onHashMessage);
|
|
});
|
|
}
|
|
};
|
|
resolve(this.runtimeModule);
|
|
break;
|
|
default:
|
|
logger.error('Unknown message', e.data);
|
|
URL.revokeObjectURL(objectUrl);
|
|
reject('Load error');
|
|
}
|
|
};
|
|
worker.addEventListener('message', onMessage);
|
|
} catch (err) {
|
|
reject(err);
|
|
}
|
|
}).catch(err => {
|
|
logger.warn('WebAssembly error', err);
|
|
return this.loadAsmJsFallbackRuntime();
|
|
});
|
|
},
|
|
|
|
workerPostRun() {
|
|
self.postMessage({ op: 'postRun' });
|
|
self.onmessage = e => {
|
|
try {
|
|
const hash = self.Module.calcHash(self.Module, e.data);
|
|
self.postMessage({ hash });
|
|
} catch (e) {
|
|
self.postMessage({ error: e.toString() });
|
|
}
|
|
};
|
|
},
|
|
|
|
loadAsmJsFallbackRuntime() {
|
|
logger.debug('Loading asm.js fallback runtime');
|
|
return new Promise(resolve => {
|
|
const ts = logger.ts();
|
|
global.Module = undefined;
|
|
const argon2Code = require('argon2-asm');
|
|
global.eval(argon2Code); // eslint-disable-line
|
|
this.runtimeModule = {
|
|
hash: args => Promise.resolve().then(() => this.calcHash(global.Module, args))
|
|
};
|
|
logger.debug('Fallback runtime loaded', logger.ts(ts));
|
|
resolve(this.runtimeModule);
|
|
});
|
|
},
|
|
|
|
calcHash(Module, args) {
|
|
let { password, salt } = args;
|
|
const { memory, iterations, length, parallelism, type, version } = args;
|
|
const passwordLen = password.byteLength;
|
|
password = Module.allocate(new Uint8Array(password), 'i8', Module.ALLOC_NORMAL);
|
|
const saltLen = salt.byteLength;
|
|
salt = Module.allocate(new Uint8Array(salt), 'i8', Module.ALLOC_NORMAL);
|
|
const hash = Module.allocate(new Array(length), 'i8', Module.ALLOC_NORMAL);
|
|
const encodedLen = 512;
|
|
const encoded = Module.allocate(new Array(encodedLen), 'i8', Module.ALLOC_NORMAL);
|
|
|
|
const res = Module._argon2_hash(iterations, memory, parallelism,
|
|
password, passwordLen, salt, saltLen,
|
|
hash, length, encoded, encodedLen, type, version);
|
|
if (res) {
|
|
throw new Error('Argon2 error ' + res);
|
|
}
|
|
const hashArr = new Uint8Array(length);
|
|
for (let i = 0; i < length; i++) {
|
|
hashArr[i] = Module.HEAP8[hash + i];
|
|
}
|
|
Module._free(password);
|
|
Module._free(salt);
|
|
Module._free(hash);
|
|
Module._free(encoded);
|
|
return hashArr;
|
|
}
|
|
};
|
|
|
|
module.exports = KdbxwebInit;
|