1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
const alasql = require('alasql');
const openpgp = require('openpgp');
openpgp.initWorker({path: 'openpgp.worker.js'});
let encrypted, decrypted; // REMEMBER: Remove testing variables (leaking)
function setupDatabase() {
// REMEMBER: "key" and "type" are names reserved for SQL
alasql('CREATE localstorage DATABASE IF NOT EXISTS texx');
alasql('ATTACH localStorage DATABASE texx AS db');
alasql('CREATE TABLE IF NOT EXISTS db.own_keys (key_type STRING, key_data STRING)');
alasql('CREATE TABLE IF NOT EXISTS db.keys (peer_id STRING, key_data STRING)');
alasql('CREATE TABLE IF NOT EXISTS db.messages (id INT AUTO_INCREMENT, message STRING)');
return true;
}
/**
* Generates and stores encrypted private key, public key and a revocation certificate
* @param peerId
* @param passphrase
* @returns {Promise<void>}
*/
async function generateKeys(peerId, passphrase) {
const options = {
userIds: [{name: peerId}],
numBits: 4096,
passphrase: passphrase
};
await openpgp.generateKey(options).then((key) => {
alasql(`INSERT INTO db.own_keys VALUES ("private_key", "${key.privateKeyArmored}")`);
alasql(`INSERT INTO db.own_keys VALUES ("public_key", "${key.publicKeyArmored}")`);
alasql(`INSERT INTO db.own_keys VALUES ("revocation_certificate", "${key.revocationCertificate}")`);
console.log('[LOG] Successfully generated and stored keys!');
});
}
/**
* Gets the peers private key
* @returns {string}
*/
function getPrivateKey() {
const privateKey = alasql('SELECT key_data FROM db.own_keys WHERE key_type = "private_key" LIMIT 1');
return privateKey.length > 0 ? privateKey[0]['key_data'] : '';
}
/**
* Gets the peers public key
* @returns {string}
*/
function getPublicKey() {
const publicKey = alasql('SELECT key_data FROM db.own_keys WHERE key_type = "public_key" LIMIT 1');
return publicKey.length > 0 ? publicKey[0]['key_data'] : '';
}
/**
* Gets the peers revocation certificate
* @returns {string}
*/
function getRevocationCertificate() {
const revocationCertificate = alasql('SELECT key_data FROM db.own_keys WHERE key_type = "revocation_certificate" LIMIT 1');
return revocationCertificate.length > 0 ? revocationCertificate[0]['key_data'] : '';
}
/**
* Encrypts the data with a public key (e.g the one of the peer with which you're chatting)
* @param data
* @param publicKey
* @returns {Promise<void>}
*/
async function encrypt(data, publicKey) {
//const privateKeyObj = (await openpgp.key.readArmored(privateKey)).keys[0];
//await privateKeyObj.decrypt(passphrase);
const options = {
message: openpgp.message.fromText(data),
publicKeys: (await openpgp.key.readArmored(publicKey)).keys,
//privateKeys: [privateKeyObj] TODO: Use private key for signing
};
await openpgp.encrypt(options).then(ciphertext => {
encrypted = ciphertext.data;
console.log(encrypted);
//return encrypted; // TODO: Return encrypted from async function
})
}
/**
* Decrypts encrypted data with own encrypted private key and verifies the data with the public key
* @param data
* @param publicKey
* @param privateKey
* @param passphrase
* @returns {Promise<void>}
*/
async function decrypt(data, publicKey, privateKey, passphrase) {
const privateKeyObj = (await openpgp.key.readArmored(privateKey)).keys[0];
await privateKeyObj.decrypt(passphrase);
const options = {
message: await openpgp.message.readArmored(data),
publicKeys: (await openpgp.key.readArmored(publicKey)).keys, // for verification
privateKeys: [privateKeyObj]
};
await openpgp.decrypt(options).then(plaintext => {
decrypted = plaintext.data;
console.log(plaintext.data);
//return plaintext.data
})
}
/**
* Checks whether the peer has keys
* @returns {boolean}
*/
function isEncrypted() {
const hasPrivateKey = getPrivateKey() !== '';
const hasPublicKey = getPublicKey() !== '';
const hasRevocationCertificate = getRevocationCertificate() !== '';
return (hasPrivateKey && hasPublicKey && hasRevocationCertificate);
}
/**
* Stores the public key of a peer
* @param peerId
* @param key
*/
function storePublicKey(peerId, key) {
alasql(`INSERT INTO db.keys VALUES ("${peerId}", "${key}")`);
console.log('[LOG] Stored public key of ' + peerId);
}
/**
* Just a general test case
*/
function testEncryption() {
generateKeys('test_id', 'supersecure').then(() => {
encrypt('The meaning of life', getPublicKey()).then(() => {
decrypt(encrypted, getPublicKey(), getPrivateKey(), 'supersecure').then(() => {
if (decrypted === 'The meaning of life')
console.log("YEEHA, Test succeeded!")
})
})
})
}
exports.setup = setupDatabase;
exports.generate = generateKeys;
exports.getPrivate = getPrivateKey;
exports.getPublic = getPublicKey;
exports.encrypt = encrypt;
exports.decrypt = decrypt;
exports.check = isEncrypted;
exports.store = storePublicKey;
exports.test = testEncryption;
|
