2018-04-19 06:00:53 +02:00
|
|
|
import * as constants from 'constants';
|
2018-04-20 05:12:06 +02:00
|
|
|
import * as crypto from 'crypto';
|
2018-04-20 21:32:25 +02:00
|
|
|
import * as forge from 'node-forge';
|
2018-04-15 05:20:37 +02:00
|
|
|
|
|
|
|
import { CryptoFunctionService } from '../abstractions/cryptoFunction.service';
|
|
|
|
|
2018-04-20 21:32:25 +02:00
|
|
|
import { Utils } from '../misc/utils';
|
|
|
|
|
2018-04-15 05:20:37 +02:00
|
|
|
export class NodeCryptoFunctionService implements CryptoFunctionService {
|
2018-04-18 14:50:02 +02:00
|
|
|
pbkdf2(password: string | ArrayBuffer, salt: string | ArrayBuffer, algorithm: 'sha256' | 'sha512',
|
2018-04-18 03:18:47 +02:00
|
|
|
iterations: number): Promise<ArrayBuffer> {
|
|
|
|
const len = algorithm === 'sha256' ? 256 : 512;
|
2018-04-17 21:59:38 +02:00
|
|
|
const nodePassword = this.toNodeValue(password);
|
|
|
|
const nodeSalt = this.toNodeValue(salt);
|
2018-04-15 05:20:37 +02:00
|
|
|
return new Promise<ArrayBuffer>((resolve, reject) => {
|
2018-04-16 18:07:51 +02:00
|
|
|
crypto.pbkdf2(nodePassword, nodeSalt, iterations, length, algorithm, (error, key) => {
|
2018-04-15 05:20:37 +02:00
|
|
|
if (error != null) {
|
|
|
|
reject(error);
|
|
|
|
} else {
|
2018-04-20 16:59:55 +02:00
|
|
|
resolve(this.toArrayBuffer(key));
|
2018-04-15 05:20:37 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
2018-04-17 21:59:38 +02:00
|
|
|
|
2018-04-18 14:50:02 +02:00
|
|
|
hash(value: string | ArrayBuffer, algorithm: 'sha1' | 'sha256' | 'sha512'): Promise<ArrayBuffer> {
|
2018-04-17 21:59:38 +02:00
|
|
|
const nodeValue = this.toNodeValue(value);
|
|
|
|
const hash = crypto.createHash(algorithm);
|
|
|
|
hash.update(nodeValue);
|
2018-04-20 16:59:55 +02:00
|
|
|
return Promise.resolve(this.toArrayBuffer(hash.digest()));
|
2018-04-17 21:59:38 +02:00
|
|
|
}
|
|
|
|
|
2018-04-18 14:50:02 +02:00
|
|
|
hmac(value: ArrayBuffer, key: ArrayBuffer, algorithm: 'sha1' | 'sha256' | 'sha512'): Promise<ArrayBuffer> {
|
|
|
|
const nodeValue = this.toNodeBuffer(value);
|
|
|
|
const nodeKey = this.toNodeBuffer(value);
|
|
|
|
const hmac = crypto.createHmac(algorithm, nodeKey);
|
|
|
|
hmac.update(nodeValue);
|
2018-04-20 16:59:55 +02:00
|
|
|
return Promise.resolve(this.toArrayBuffer(hmac.digest()));
|
2018-04-18 14:50:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
aesEncrypt(data: ArrayBuffer, iv: ArrayBuffer, key: ArrayBuffer): Promise<ArrayBuffer> {
|
|
|
|
const nodeData = this.toNodeBuffer(data);
|
|
|
|
const nodeIv = this.toNodeBuffer(iv);
|
|
|
|
const nodeKey = this.toNodeBuffer(key);
|
|
|
|
const cipher = crypto.createCipheriv('aes-256-cbc', nodeKey, nodeIv);
|
|
|
|
const encBuf = Buffer.concat([cipher.update(nodeData), cipher.final()]);
|
2018-04-20 16:59:55 +02:00
|
|
|
return Promise.resolve(this.toArrayBuffer(encBuf));
|
2018-04-18 14:50:02 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
aesDecryptSmall(data: ArrayBuffer, iv: ArrayBuffer, key: ArrayBuffer): Promise<ArrayBuffer> {
|
|
|
|
return this.aesDecryptLarge(data, iv, key);
|
|
|
|
}
|
|
|
|
|
|
|
|
aesDecryptLarge(data: ArrayBuffer, iv: ArrayBuffer, key: ArrayBuffer): Promise<ArrayBuffer> {
|
|
|
|
const nodeData = this.toNodeBuffer(data);
|
|
|
|
const nodeIv = this.toNodeBuffer(iv);
|
|
|
|
const nodeKey = this.toNodeBuffer(key);
|
|
|
|
const decipher = crypto.createDecipheriv('aes-256-cbc', nodeKey, nodeIv);
|
|
|
|
const decBuf = Buffer.concat([decipher.update(nodeData), decipher.final()]);
|
2018-04-20 16:59:55 +02:00
|
|
|
return Promise.resolve(this.toArrayBuffer(decBuf));
|
2018-04-18 14:50:02 +02:00
|
|
|
}
|
|
|
|
|
2018-04-20 21:32:25 +02:00
|
|
|
rsaEncrypt(data: ArrayBuffer, publicKey: ArrayBuffer, algorithm: 'sha1' | 'sha256'): Promise<ArrayBuffer> {
|
|
|
|
let md: forge.md.MessageDigest;
|
|
|
|
if (algorithm === 'sha256') {
|
|
|
|
md = forge.md.sha256.create();
|
|
|
|
} else {
|
|
|
|
md = forge.md.sha1.create();
|
2018-04-19 06:00:53 +02:00
|
|
|
}
|
|
|
|
|
2018-04-20 21:32:25 +02:00
|
|
|
const dataBytes = Utils.fromBufferToByteString(data);
|
|
|
|
const key = this.toForgePublicKey(publicKey);
|
|
|
|
const decBytes: string = key.encrypt(dataBytes, 'RSA-OAEP', { md: md });
|
|
|
|
return Promise.resolve(Utils.fromByteStringToArray(decBytes).buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
rsaDecrypt(data: ArrayBuffer, privateKey: ArrayBuffer, algorithm: 'sha1' | 'sha256'): Promise<ArrayBuffer> {
|
|
|
|
let md: forge.md.MessageDigest;
|
|
|
|
if (algorithm === 'sha256') {
|
|
|
|
md = forge.md.sha256.create();
|
|
|
|
} else {
|
|
|
|
md = forge.md.sha1.create();
|
|
|
|
}
|
|
|
|
|
|
|
|
const dataBytes = Utils.fromBufferToByteString(data);
|
|
|
|
const key = this.toForgePrivateKey(privateKey);
|
|
|
|
const decBytes: string = key.decrypt(dataBytes, 'RSA-OAEP', { md: md });
|
|
|
|
return Promise.resolve(Utils.fromByteStringToArray(decBytes).buffer);
|
2018-04-19 06:00:53 +02:00
|
|
|
}
|
|
|
|
|
2018-04-18 14:50:02 +02:00
|
|
|
randomBytes(length: number): Promise<ArrayBuffer> {
|
|
|
|
return new Promise<ArrayBuffer>((resolve, reject) => {
|
|
|
|
crypto.randomBytes(length, (error, bytes) => {
|
|
|
|
if (error != null) {
|
|
|
|
reject(error);
|
|
|
|
} else {
|
2018-04-20 16:59:55 +02:00
|
|
|
resolve(this.toArrayBuffer(bytes));
|
2018-04-18 14:50:02 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
2018-04-18 01:02:58 +02:00
|
|
|
}
|
|
|
|
|
2018-04-17 21:59:38 +02:00
|
|
|
private toNodeValue(value: string | ArrayBuffer): string | Buffer {
|
|
|
|
let nodeValue: string | Buffer;
|
|
|
|
if (typeof (value) === 'string') {
|
|
|
|
nodeValue = value;
|
|
|
|
} else {
|
2018-04-18 14:50:02 +02:00
|
|
|
nodeValue = this.toNodeBuffer(value);
|
2018-04-17 21:59:38 +02:00
|
|
|
}
|
|
|
|
return nodeValue;
|
|
|
|
}
|
2018-04-18 14:50:02 +02:00
|
|
|
|
|
|
|
private toNodeBuffer(value: ArrayBuffer): Buffer {
|
2018-04-18 19:43:42 +02:00
|
|
|
return Buffer.from(new Uint8Array(value) as any);
|
2018-04-18 14:50:02 +02:00
|
|
|
}
|
2018-04-19 06:00:53 +02:00
|
|
|
|
2018-04-20 16:59:55 +02:00
|
|
|
private toArrayBuffer(buf: Buffer): ArrayBuffer {
|
|
|
|
return new Uint8Array(buf).buffer;
|
|
|
|
}
|
|
|
|
|
2018-04-20 21:32:25 +02:00
|
|
|
private toForgePrivateKey(key: ArrayBuffer): any {
|
|
|
|
const byteString = Utils.fromBufferToByteString(key);
|
|
|
|
const asn1 = forge.asn1.fromDer(byteString);
|
|
|
|
return (forge as any).pki.privateKeyFromAsn1(asn1);
|
|
|
|
}
|
|
|
|
|
|
|
|
private toForgePublicKey(key: ArrayBuffer): any {
|
|
|
|
const byteString = Utils.fromBufferToByteString(key);
|
|
|
|
const asn1 = forge.asn1.fromDer(byteString);
|
|
|
|
return (forge as any).pki.publicKeyFromAsn1(asn1);
|
2018-04-19 06:00:53 +02:00
|
|
|
}
|
2018-04-15 05:20:37 +02:00
|
|
|
}
|