reorganization of source code

public/javascripts/encryption.js

@@ -0,0 +1,370 @@
+let globalEncryptionCallback = null;
+
+function handleEncryption(requireEncryption, modal, callback) {
+    if (requireEncryption && globalDataKey === null) {
+        globalEncryptionCallback = callback;
+
+        $("#encryption-password-dialog").dialog({
+            modal: modal,
+            width: 400,
+            open: () => {
+                if (!modal) {
+                    // dialog steals focus for itself, which is not what we want for non-modal (viewing)
+                    getNodeByKey(globalCurrentNote.detail.note_id).setFocus();
+                }
+            }
+        });
+    }
+    else {
+        callback();
+    }
+}
+
+let globalDataKey = null;
+let globalLastEncryptionOperationDate = null;
+
+function getDataKey(password) {
+    return computeScrypt(password, globalEncryptionSalt, (key, resolve, reject) => {
+        const dataKeyAes = getDataKeyAes(key);
+
+        const decryptedDataKey = decrypt(dataKeyAes, globalEncryptedDataKey);
+
+        if (decryptedDataKey === false) {
+            reject("Wrong password.");
+        }
+
+        resolve(decryptedDataKey);
+    });
+}
+
+function computeScrypt(password, salt, callback) {
+    const normalizedPassword = password.normalize('NFKC');
+    const passwordBuffer = new buffer.SlowBuffer(normalizedPassword);
+    const saltBuffer = new buffer.SlowBuffer(salt);
+
+    // this settings take ~500ms on my laptop
+    const N = 16384, r = 8, p = 1;
+    // 32 byte key - AES 256
+    const dkLen = 32;
+
+    const startedDate = new Date();
+
+    return new Promise((resolve, reject) => {
+        scrypt(passwordBuffer, saltBuffer, N, r, p, dkLen, (error, progress, key) => {
+            if (error) {
+                console.log("Error: " + error);
+
+                reject();
+            }
+            else if (key) {
+                console.log("Computation took " + (new Date().getTime() - startedDate.getTime()) + "ms");
+
+                callback(key, resolve, reject);
+            }
+            else {
+                // update UI with progress complete
+            }
+        });
+    });
+}
+
+$("#encryption-password-form").submit(() => {
+    const password = $("#encryption-password").val();
+    $("#encryption-password").val("");
+
+    getDataKey(password).then(key => {
+        $("#encryption-password-dialog").dialog("close");
+
+        globalDataKey = key;
+
+        for (const noteId of globalAllNoteIds) {
+            const note = getNodeByKey(noteId);
+
+            if (note.data.encryption > 0) {
+                const title = decryptString(note.data.note_title);
+
+                note.setTitle(title);
+            }
+        }
+
+        if (globalEncryptionCallback !== null) {
+            globalEncryptionCallback();
+
+            globalEncryptionCallback = null;
+        }
+    })
+        .catch(reason => {
+            console.log(reason);
+
+            alert(reason);
+        });
+
+    return false;
+});
+
+function resetEncryptionSession() {
+    globalDataKey = null;
+
+    if (globalCurrentNote.detail.encryption > 0) {
+        loadNoteToEditor(globalCurrentNote.detail.note_id);
+
+        for (const noteId of globalAllNoteIds) {
+            const note = getNodeByKey(noteId);
+
+            if (note.data.encryption > 0) {
+                note.setTitle("[encrypted]");
+            }
+        }
+    }
+}
+
+setInterval(() => {
+    if (globalLastEncryptionOperationDate !== null && new Date().getTime() - globalLastEncryptionOperationDate.getTime() > globalEncryptionSessionTimeout * 1000) {
+        resetEncryptionSession();
+    }
+}, 5000);
+
+function isEncryptionAvailable() {
+    return globalDataKey !== null;
+}
+
+function getDataAes() {
+    globalLastEncryptionOperationDate = new Date();
+
+    return new aesjs.ModeOfOperation.ctr(globalDataKey, new aesjs.Counter(5));
+}
+
+function getDataKeyAes(key) {
+    return new aesjs.ModeOfOperation.ctr(key, new aesjs.Counter(5));
+}
+
+function encryptNoteIfNecessary(note) {
+    if (note.detail.encryption === 0) {
+        return note;
+    }
+    else {
+        return encryptNote(note);
+    }
+}
+
+function encryptString(str) {
+    return encrypt(getDataAes(), str);
+}
+
+function encrypt(aes, str) {
+    const payload = aesjs.utils.utf8.toBytes(str);
+    const digest = sha256Array(payload).slice(0, 4);
+
+    const digestWithPayload = concat(digest, payload);
+
+    const encryptedBytes = aes.encrypt(digestWithPayload);
+
+    return uint8ToBase64(encryptedBytes);
+}
+
+function decryptString(encryptedBase64) {
+    const decryptedBytes = decrypt(getDataAes(), encryptedBase64);
+
+    return aesjs.utils.utf8.fromBytes(decryptedBytes);
+}
+
+function decrypt(aes, encryptedBase64) {
+    const encryptedBytes = base64ToUint8Array(encryptedBase64);
+
+    const decryptedBytes = aes.decrypt(encryptedBytes);
+
+    const digest = decryptedBytes.slice(0, 4);
+    const payload = decryptedBytes.slice(4);
+
+    const hashArray = sha256Array(payload);
+
+    const computedDigest = hashArray.slice(0, 4);
+
+    if (!arraysIdentical(digest, computedDigest)) {
+        return false;
+    }
+
+    return payload;
+}
+
+function concat(a, b) {
+    const result = [];
+
+    for (let key in a) {
+        result.push(a[key]);
+    }
+
+    for (let key in b) {
+        result.push(b[key]);
+    }
+
+    return result;
+}
+
+function sha256Array(content) {
+    const hash = sha256.create();
+    hash.update(content);
+    return hash.array();
+}
+
+function arraysIdentical(a, b) {
+    let i = a.length;
+    if (i !== b.length) return false;
+    while (i--) {
+        if (a[i] !== b[i]) return false;
+    }
+    return true;
+}
+
+function encryptNote(note) {
+    note.detail.note_title = encryptString(note.detail.note_title);
+    note.detail.note_text = encryptString(note.detail.note_text);
+
+    note.detail.encryption = 1;
+
+    return note;
+}
+
+function encryptNoteAndSendToServer() {
+    handleEncryption(true, true, () => {
+        const note = globalCurrentNote;
+
+        updateNoteFromInputs(note);
+
+        encryptNote(note);
+
+        saveNoteToServer(note);
+
+        setNoteBackgroundIfEncrypted(note);
+    });
+}
+
+function decryptNoteAndSendToServer() {
+    handleEncryption(true, true, () => {
+        const note = globalCurrentNote;
+
+        updateNoteFromInputs(note);
+
+        note.detail.encryption = 0;
+
+        saveNoteToServer(note);
+
+        setNoteBackgroundIfEncrypted(note);
+    });
+}
+
+function decryptNoteIfNecessary(note) {
+    if (note.detail.encryption > 0) {
+        decryptNote(note);
+    }
+}
+
+function decryptNote(note) {
+    note.detail.note_title = decryptString(note.detail.note_title);
+    note.detail.note_text = decryptString(note.detail.note_text);
+}
+
+function encryptSubTree(noteId) {
+    handleEncryption(true, true, () => {
+        updateSubTreeRecursively(noteId, note => {
+            if (note.detail.encryption === null || note.detail.encryption === 0) {
+                encryptNote(note);
+
+                note.detail.encryption = 1;
+
+                return true;
+            }
+            else {
+                return false;
+            }
+        },
+            note => {
+                if (note.detail.note_id === globalCurrentNote.detail.note_id) {
+                    loadNoteToEditor(note.detail.note_id);
+                }
+                else {
+                    setTreeBasedOnEncryption(note);
+                }
+            });
+
+        alert("Encryption finished.");
+    });
+}
+
+function decryptSubTree(noteId) {
+    handleEncryption(true, true, () => {
+        updateSubTreeRecursively(noteId, note => {
+            if (note.detail.encryption === 1) {
+                decryptNote(note);
+
+                note.detail.encryption = 0;
+
+                return true;
+            }
+            else {
+                return false;
+            }
+        },
+            note => {
+                if (note.detail.note_id === globalCurrentNote.detail.note_id) {
+                    loadNoteToEditor(note.detail.note_id);
+                }
+                else {
+                    setTreeBasedOnEncryption(note);
+                }
+            });
+
+        alert("Decryption finished.");
+    });
+}
+
+function updateSubTreeRecursively(noteId, updateCallback, successCallback) {
+    updateNoteSynchronously(noteId, updateCallback, successCallback);
+
+    const node = getNodeByKey(noteId);
+    if (!node || !node.getChildren()) {
+        return;
+    }
+
+    for (const child of node.getChildren()) {
+        updateSubTreeRecursively(child.key, updateCallback, successCallback);
+    }
+}
+
+function updateNoteSynchronously(noteId, updateCallback, successCallback) {
+    $.ajax({
+        url: baseApiUrl + 'notes/' + noteId,
+        type: 'GET',
+        async: false,
+        success: note => {
+            const needSave = updateCallback(note);
+
+            if (!needSave) {
+                return;
+            }
+
+            for (const link of note.links) {
+                delete link.type;
+            }
+
+            $.ajax({
+                url: baseApiUrl + 'notes/' + noteId,
+                type: 'PUT',
+                data: JSON.stringify(note),
+                contentType: "application/json",
+                async: false,
+                success: () => {
+                    if (successCallback) {
+                        successCallback(note);
+                    }
+                },
+                error: () => {
+                    console.log("Updating " + noteId + " failed.");
+                }
+            });
+        },
+        error: () => {
+            console.log("Reading " + noteId + " failed.");
+        }
+    });
+}