RanchiMall/messenger
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed Mail and backup issues

Browse Source
This commit is contained in:
sairajzero 2020-12-14 03:59:09 +05:30
parent e12711bb3a
commit ef9c8eba0f
1 changed files with 113 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

260
index.html
View File

@ -1569,10 +1569,10 @@
let subject = subjectOfReplyMail.value; let subject = subjectOfReplyMail.value;
let content = replyMailContent.value; let content = replyMailContent.value;
let prevRef = replyMailPopup.dataset.prevRef; let prevRef = replyMailPopup.dataset.prevRef;
messenger.replyMail(prevRef, subject, content, recipient).then(data => { messenger.sendMail(subject, content, recipient, prevRef).then(data => {
notify(`Mail replied!`); notify(`Mail replied!`);
replyMailPopup.hide() replyMailPopup.hide()
let {ref, subject, time, category, floID, content} = data let {ref, subject, time, from, to, prev, content} = data
sentMailContainer.prepend(render.mailCard(ref, subject, time, category, floID, content)); sentMailContainer.prepend(render.mailCard(ref, subject, time, category, floID, content));
}).catch(error => notify("Failed to send mail!", "error", error)) }).catch(error => notify("Failed to send mail!", "error", error))
} }
@ -10926,7 +10926,6 @@ Bitcoin.Util = {
var obj = { var obj = {
messages: {}, messages: {},
mails: {}, mails: {},
mailRef: {},
marked: {}, marked: {},
groupInfo: {}, groupInfo: {},
groupMsg: {}, groupMsg: {},
@ -10961,72 +10960,38 @@ Bitcoin.Util = {
}) })
}, },
sendMail(subject, content, recipients) { sendMail(subject, content, recipients, prev = null) {
return new Promise(async (resolve, reject) => { return new Promise(async (resolve, reject) => {
let result = { if (!Array.isArray(recipients))
success: {}, recipients = [recipients]
error: {}
}
let mail = { let mail = {
subject: subject, subject: subject,
content: content, content: content,
ref: floCrypto.randString(32, true) ref: Date.now() + floCrypto.randString(8, true),
} prev: prev
for (let i = 0; i < recipients.length; i++) {
try {
if (recipients[i] in floGlobals.pubKeys)
result.success[recipients[i]] = await this.util.sendEncrypted(mail,
recipients[i]);
else
result.success[recipients[i]] = await this.util.sendEncoded(mail,
recipients[i]);
} catch (error) {
result.error[recipients[i]] = error;
}
}
let data = {
time: Date.now(),
floID: Object.keys(result.success),
category: "sentTo",
subject: subject,
ref: mail.ref
}
compactIDB.addData("mails", data, `${data.time}`)
compactIDB.addData("mailContent", this.util.encrypt(content), `${data.time}`)
compactIDB.addData("mailRef", `${data.time}`, mail.ref)
result.data = data
resolve(result)
})
},
replyMail(prevRef, subject, content, recipient) {
return new Promise(async (resolve, reject) => {
let mail = {
prevRef: prevRef,
subject: subject,
content: content,
ref: floCrypto.randString(32, true)
}
try {
if (recipient in floGlobals.pubKeys)
await this.util.sendEncrypted(mail, recipient);
else
await this.util.sendEncoded(mail, recipient);
let data = {
time: Date.now(),
floID: recipient,
category: "replyTo",
prevRef: prevRef,
subject: subject,
ref: mail.ref
}
compactIDB.addData("mails", data, `${data.time}`)
compactIDB.addData("mailContent", this.util.encrypt(content), `${data.time}`)
compactIDB.addData("mailRef", `${data.time}`, mail.ref)
resolve(data)
} catch (error) {
reject(error)
} }
let promises = recipients.map(r => this.util.sendRaw(JSON.stringify(mail), r, "MAIL"))
Promise.allSettled(promises).then(results => {
mail.time = Date.now();
mail.from = myFloID
mail.to = []
results.forEach(r => {
if (r.status === "fulfilled") {
let vc = Object.keys(r.value).pop()
mail.to.push(r.value[vc].receiverID)
}
})
if (mail.to.length === 0)
return reject(results)
mail.content = this.util.encrypt(content)
compactIDB.addData("mails", {
...mail
}, mail.ref)
mail.content = content
resolve({
[mail.ref]: mail
});
})
}) })
}, },
@ -11046,41 +11011,42 @@ Bitcoin.Util = {
try { try {
//store the pubKey if not stored already //store the pubKey if not stored already
floDapps.storePubKey(dataSet[vc].senderID, dataSet[vc].pubKey) floDapps.storePubKey(dataSet[vc].senderID, dataSet[vc].pubKey)
let data = {
time: dataSet[vc].time,
floID: dataSet[vc].senderID,
}
if (dataSet[vc].message instanceof Object && "secret" in dataSet[vc] if (dataSet[vc].message instanceof Object && "secret" in dataSet[vc]
.message) .message)
dataSet[vc].message = floCrypto.decryptData(dataSet[vc].message, dataSet[vc].message = floCrypto.decryptData(dataSet[vc].message,
myPrivKey) myPrivKey)
if (dataSet[vc].type === "MESSAGE") { if (dataSet[vc].type === "MESSAGE") {
//process as message //process as message
data.category = "received" let dm = {
data.message = messenger.util.encrypt(dataSet[vc].message); time: dataSet[vc].time,
floID: dataSet[vc].senderID,
category: "received",
message: messenger.util.encrypt(dataSet[vc].message)
}
compactIDB.addData("messages", { compactIDB.addData("messages", {
...data ...dm
}, vc) }, vc)
data.message = dataSet[vc].message; dm.message = dataSet[vc].message;
newInbox.messages[vc] = data; newInbox.messages[vc] = dm;
messenger.addMark(data.floID, "unread") messenger.addMark(dm.floID, "unread")
} else if (dataSet[vc].type === "MAIL") { } else if (dataSet[vc].type === "MAIL") {
//process as mail //process as mail
data.subject = dataSet[vc].message.subject; let data = JSON.parse(dataSet[vc].message);
data.ref = dataSet[vc].message.ref; let mail = {
if (dataSet[vc].message.prevRef) { time: dataSet[vc].time,
data.prevRef = dataSet[vc].message.prevRef; from: dataSet[vc].senderID,
data.category = "replyFrom"; to: [myFloID],
} else subject: data.subject,
data.category = "receivedFrom" content: messenger.util.encrypt(data.content),
data.content = messenger.util.encrypt(dataSet[vc].message.content) ref: data.ref,
prev: data.prev
}
compactIDB.addData("mails", { compactIDB.addData("mails", {
...data ...mail
}, vc); }, mail.ref);
compactIDB.addData("mailRef", vc, data.ref) mail.content = dataSet[vc].message.content;
data.content = dataSet[vc].message.content; newInbox.mails[mail.ref] = mail;
newInbox.mails[vc] = data; messenger.addMark(mail.ref, "unread")
messenger.addMark(data.ref, "unread")
} else if (dataSet[vc].type === "CREATE_GROUP") { } else if (dataSet[vc].type === "CREATE_GROUP") {
//process create group //process create group
let groupInfo = JSON.parse(dataSet[vc].message); let groupInfo = JSON.parse(dataSet[vc].message);
@ -11129,13 +11095,9 @@ Bitcoin.Util = {
getMail(mailRef) { getMail(mailRef) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
compactIDB.readData("mailRef", mailRef).then(result => { compactIDB.readData("mails", mailRef).then(mail => {
let promises = [compactIDB.readData("mails", result), compactIDB.readData( mail.content = this.util.decrypt(mail.content)
"mailContent", result)] resolve(mail)
Promise.all(promises).then(results => {
results[0].content = Crypto.AES.decrypt(results[1]);
resolve(results[0]);
}).catch(error => reject(error))
}).catch(error => reject(error)) }).catch(error => reject(error))
}); });
}, },
@ -11176,32 +11138,48 @@ Bitcoin.Util = {
return floDapps.storeContact(floID, name) return floDapps.storeContact(floID, name)
}, },
loadDataFromIDB() { loadDataFromIDB(dataList = 'default') {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
let loadData = ["messages", "mails", "marked", "groupMsg", "groupInfo", "appendix"] if (dataList === 'default')
dataList = ["messages", "mails", "marked", "groupMsg", "groupInfo", "appendix"]
else if (dataList === 'all')
dataList = ["messages", "mails", "marked", "groupMsg", "groupInfo", "groupKey",
"appendix"
]
let promises = [] let promises = []
for (var i = 0; i < loadData.length; i++) for (var i = 0; i < dataList.length; i++)
promises[i] = compactIDB.readAllData(loadData[i]) promises[i] = compactIDB.readAllData(dataList[i])
Promise.all(promises).then(results => { Promise.all(promises).then(results => {
let data = {} let data = {}
for (var i = 0; i < loadData.length; i++) for (var i = 0; i < dataList.length; i++)
data[loadData[i]] = results[i] data[dataList[i]] = results[i]
data.appendix.lastReceived = data.appendix.lastReceived || '0' data.appendix.lastReceived = data.appendix.lastReceived || '0'
if (data.appendix.AESKey) { if (data.appendix.AESKey) {
try { try {
let AESKey = floCrypto.decryptData(data.appendix.AESKey, myPrivKey); let AESKey = floCrypto.decryptData(data.appendix.AESKey, myPrivKey);
data.appendix.AESKey = AESKey; data.appendix.AESKey = AESKey;
for (let m in data.messages) { if ("messages" in dataList)
let decrypted = Crypto.AES.decrypt(data.messages[m].message, for (let m in data.messages)
AESKey) data.messages[m].message = this.util.decrypt(data.messages[m]
data.messages[m].message = decrypted; .message, AESKey)
} if ("mails" in dataList)
for (let m in data.mails)
data.mails[m].content = this.util.decrypt(data.mails[m].content,
AESKey)
if ("groupKey" in dataList)
for (let k in data.groupKeys)
data.groupKeys[k] = this.util.decrypt(data.groupKeys[k], AESKey)
if ("groupMsg" in dataList)
for (let m in data.groupMsg)
if (datdata.groupMsg[m].message)
data.groupMsg[m].message = this.util.decrypt(data.groupMsg[
m].message, AESKey)
resolve(data) resolve(data)
} catch (error) { } catch (error) {
reject("Corrupted AES Key"); reject("Corrupted AES Key");
} }
} else { } else {
if (Object.keys(data.messages).length) if (Object.keys(data.messages).length || Object.keys(data.mails).length)
return reject("AES Key not Found") return reject("AES Key not Found")
let AESKey = floCrypto.randString(32); let AESKey = floCrypto.randString(32);
let encryptedKey = floCrypto.encryptData(AESKey, myPubKey); let encryptedKey = floCrypto.encryptData(AESKey, myPubKey);
@ -11216,24 +11194,16 @@ Bitcoin.Util = {
backupData() { backupData() {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
let obs = ["contacts", "pubKeys", "messages", "mails", "mailContent", "mailRef", "marked", this.loadDataFromIDB("all").then(data => {
"appendix" delete data.appendix.AESKey;
]
let promises = [];
obs.forEach(o => promises.push(compactIDB.readAllData(o)))
Promise.all(promises).then(results => {
let data = {}
for (let i = 0; i < obs.length; i++)
data[obs[i]] = results[i]
results = undefined;
data = btoa(unescape(encodeURIComponent(JSON.stringify(data)))) data = btoa(unescape(encodeURIComponent(JSON.stringify(data))))
data = { let blobData = {
floID: myFloID, floID: myFloID,
pubKey: myPubKey, pubKey: myPubKey,
data: floCrypto.encryptData(data, myPubKey), data: this.util.encrypt(data, myPrivKey),
} }
data.sign = floCrypto.signData(JSON.stringify(data.data), myPrivKey); blobData.sign = floCrypto.signData(blobData.data, myPrivKey);
resolve(new Blob([JSON.stringify(data)], { resolve(new Blob([JSON.stringify(blobData)], {
type: 'application/json' type: 'application/json'
})); }));
}).catch(error => reject(error)) }).catch(error => reject(error))
@ -11245,14 +11215,14 @@ Bitcoin.Util = {
if (blob instanceof Blob || blob instanceof File) { if (blob instanceof Blob || blob instanceof File) {
let reader = new FileReader(); let reader = new FileReader();
reader.onload = evt => { reader.onload = evt => {
var data = JSON.parse(evt.target.result); var blobData = JSON.parse(evt.target.result);
if (!floCrypto.verifySign(JSON.stringify(data.data), data.sign, data.pubKey)) if (!floCrypto.verifySign(blobData.data, blobData.sign, blobData.pubKey))
reject("Corrupted Backup file: Signature verification failed"); reject("Corrupted Backup file: Signature verification failed");
else if (myFloID !== data.floID || myPubKey !== data.pubKey) else if (myFloID !== blobData.floID || myPubKey !== blobData.pubKey)
reject("Invalid Backup file: Incorrect floID"); reject("Invalid Backup file: Incorrect floID");
else { else {
try { try {
data = floCrypto.decryptData(data.data, myPrivKey); let data = this.util.decrypt(blobData.data, myPrivKey)
try { try {
data = JSON.parse(decodeURIComponent(escape(atob(data)))); data = JSON.parse(decodeURIComponent(escape(atob(data))));
resolve(data) resolve(data)
@ -11272,32 +11242,28 @@ Bitcoin.Util = {
restoreData(arg) { restoreData(arg) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
let parseData;
if (arg instanceof Blob || arg instanceof File) if (arg instanceof Blob || arg instanceof File)
parseData = this.parseBackup var parseData = this.parseBackup
else else
parseData = data => new Promise((res, rej) => res(data)) var parseData = data => new Promise((res, rej) => res(data))
parseData(arg).then(data => { parseData(arg).then(data => {
if (data.appendix.lastReceived < floGlobals.appendix.lastReceived) for (let m in data.messages)
data.appendix.lastReceived = floGlobals.appendix.lastReceived; data.messages[m].message = this.util.encrypt(data.messages[m].message)
let AESKey = floCrypto.decryptData(data.appendix.AESKey, myPrivKey); for (let m in data.mail)
if (AESKey !== floGlobals.appendix.AESKey) { data.mails[m].content = this.util.encrypt(data.mails[m].content)
for (let m in data.messages) { for (let k in data.groupKeys)
let decrypted = this.util.decrypt(data.messages[m].message, AESKey) data.groupKeys[k] = this.util.encrypt(data.groupKeys[k])
let encrypted = this.util.encrypt(decrypted) for (let m in data.groupMsg)
data.messages[m].message = encrypted; if (datdata.groupMsg[m].message)
} data.groupMsg[m].message = this.util.encrypt(data.groupMsg[m].message)
for (let m in data.mailContent) { for (let l in data.appendix)
let decrypted = this.util.decrypt(data.mailContent[m], AESKey) if (l.startsWith('lastReceived') && data.appendix[l] < floGlobals.appendix[
let encrypted = this.util.encrypt(decrypted) l])
data.mailContent[m] = encrypted; data.appendix[l] = floGlobals.appendix[l]
}
}
delete data.appendix.AESKey;
let promises = []; let promises = [];
for (obs in data) for (let obs in data)
for (value in data[obs]) for (let k in data[obs])
promises.push(compactIDB.writeData(obs, data[obs][value], value)); promises.push(compactIDB.writeData(obs, data[obs][k], k));
Promise.all(promises) Promise.all(promises)
.then(results => resolve("Restore Successful")) .then(results => resolve("Restore Successful"))
.catch(error => reject("Restore Failed: Unable to write to IDB")) .catch(error => reject("Restore Failed: Unable to write to IDB"))