Skip to content

A fully open source & end-to-end encrypted note taking alternative to Evernote.

core: keep locked history sessions locked on title update (#10537)

Abdullah Atta5f94ca0eaaad
diff --git a/packages/core/__tests__/note-history.test.js b/packages/core/__tests__/note-history.test.js
index 1d4cd1dc4..a1ed39d98 100644
--- a/packages/core/__tests__/note-history.test.js
+++ b/packages/core/__tests__/note-history.test.js
@@ -190,6 +190,97 @@ test("save a locked note should add a locked session to note history", () =>
expect(unlockedContent).toMatchObject(editedContent);
}));
+test("renaming a locked note should not unlock its history session", () =>
+ noteTest().then(async ({ db, id }) => {
+ await db.vault.create("password");
+ await db.vault.add(id);
+
+ const note = await db.notes.note(id);
+ const editedContent = { type: "tiptap", data: "<p>hello world</p>" };
+ await db.vault.save({
+ ...note,
+ content: editedContent,
+ sessionId: "lockedsession"
+ });
+ await db.notes.add({
+ id,
+ title: "renamed",
+ sessionId: "lockedsession"
+ });
+
+ const sessions = await db.noteHistory.get(id).items();
+ expect(sessions).toHaveLength(1);
+
+ const lockedContent = await db.noteHistory.content(sessions[0].id);
+ expect(lockedContent.title).toBe("renamed");
+ const unlockedContent = await db.vault.decryptContent(
+ lockedContent,
+ "password"
+ );
+ expect(unlockedContent).toMatchObject(editedContent);
+
+ await db.noteHistory.restore(sessions[0].id);
+ const restored = await db.content.get((await db.notes.note(id)).contentId);
+ expect(restored.locked).toBe(true);
+ expect(
+ await db.vault.decryptContent(restored, "password")
+ ).toMatchObject(editedContent);
+ }));
+
+test("restoring a corrupted locked session should restore it as ciphertext", () =>
+ noteTest().then(async ({ db, id }) => {
+ await db.vault.create("password");
+ await db.vault.add(id);
+
+ const note = await db.notes.note(id);
+ const editedContent = { type: "tiptap", data: "<p>hello world</p>" };
+ await db.vault.save({
+ ...note,
+ content: editedContent,
+ sessionId: "lockedsession"
+ });
+ const [session] = await db.noteHistory.get(id).items();
+ await db
+ .sql()
+ .updateTable("sessioncontent")
+ .set({ locked: false })
+ .where("id", "==", session.sessionContentId)
+ .execute();
+
+ await db.noteHistory.restore(session.id);
+ const restored = await db.content.get((await db.notes.note(id)).contentId);
+ expect(restored.locked).toBe(true);
+ expect(
+ await db.vault.decryptContent(restored, "password")
+ ).toMatchObject(editedContent);
+ }));
+
+test("reading a corrupted locked session should return ciphertext", () =>
+ noteTest().then(async ({ db, id }) => {
+ await db.vault.create("password");
+ await db.vault.add(id);
+
+ const note = await db.notes.note(id);
+ const editedContent = { type: "tiptap", data: "<p>hello world</p>" };
+ await db.vault.save({
+ ...note,
+ content: editedContent,
+ sessionId: "lockedsession"
+ });
+ const [session] = await db.noteHistory.get(id).items();
+ await db
+ .sql()
+ .updateTable("sessioncontent")
+ .set({ locked: false })
+ .where("id", "==", session.sessionContentId)
+ .execute();
+
+ const lockedContent = await db.noteHistory.content(session.id);
+ expect(
+ await db.vault.decryptContent(lockedContent, "password")
+ ).toMatchObject(editedContent);
+ }));
+
test("locking an old note should clear its history", () =>
noteTest({ ...TEST_NOTE, sessionId: "notesession" }).then(
async ({ db, id }) => {
diff --git a/packages/core/src/collections/note-history.ts b/packages/core/src/collections/note-history.ts
index 18ca7ebb6..96c0f389d 100644
--- a/packages/core/src/collections/note-history.ts
+++ b/packages/core/src/collections/note-history.ts
@@ -189,7 +189,7 @@ export class NoteHistory implements ICollection {
const note = await this.db.notes.note(session.noteId);
if (!note || !content) return;
- if (session.locked && isCipher(content.data)) {
+ if (isCipher(content.data)) {
const sessionId = `${Date.now()}`;
await this.db.content.add({
id: note.contentId,
diff --git a/packages/core/src/collections/session-content.ts b/packages/core/src/collections/session-content.ts
index b5d112656..189f07044 100644
--- a/packages/core/src/collections/session-content.ts
+++ b/packages/core/src/collections/session-content.ts
@@ -25,6 +25,17 @@ import Database from "../api/index.js";
import { NoteContent, SessionContentItem, isDeleted } from "../types.js";
import { SQLCollection } from "../database/sql-collection.js";
+// sessions corrupted by an earlier bug hold ciphertext as a JSON string
+function parseCipher(data: unknown) {
+ if (typeof data !== "string" || !data.startsWith("{")) return;
+ try {
+ const parsed = JSON.parse(data);
+ return isCipher(parsed) ? parsed : undefined;
+ } catch {
+ return;
+ }
+}
+
export class SessionContent implements ICollection {
name = "sessioncontent";
readonly collection: SQLCollection<"sessioncontent", SessionContentItem>;
@@ -61,7 +72,6 @@ export class SessionContent implements ICollection {
id: sessionContentItemId,
compressed: false,
localOnly: true,
- locked: locked || false,
dateCreated: Date.now(),
dateModified: Date.now()
};
@@ -91,6 +101,12 @@ export class SessionContent implements ICollection {
}
}
+ // a title-only update must not downgrade a locked session
+ if (sessionItem.data !== undefined)
+ sessionItem.locked = isCipher(sessionItem.data);
+ else if (typeof locked === "boolean") sessionItem.locked = locked;
+ else if (!sessionContentExists) sessionItem.locked = false;
+
if (sessionContentExists) {
this.collection.update([sessionContentItemId], sessionItem);
} else {
@@ -118,11 +134,12 @@ export class SessionContent implements ICollection {
await this.collection.upsert(session);
}
+ const data =
+ session.compressed && !isCipher(session.data)
+ ? await compressor.decompress(session.data)
+ : session.data;
return {
- data:
- session.compressed && !isCipher(session.data)
- ? await compressor.decompress(session.data)
- : session.data,
+ data: parseCipher(data) || data,
type: session.contentType,
title: session.title
};