fix length

manifest.json

@@ -1,7 +1,7 @@
 {
   "id": "obsdian-save-remote",
   "name": "Save remote",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "minAppVersion": "0.12.15",
   "description": "This is yet another plugin allowing users to sync notes between local device and the cloud.",
   "author": "fyears",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-save-remote",
-  "version": "0.0.1",
+  "version": "0.0.6",
   "description": "This is yet another sync plugin for Obsidian app.",
   "scripts": {
     "dev": "webpack --mode development --watch",
@@ -13,7 +13,6 @@
   "author": "",
   "license": "Apache-2.0",
   "devDependencies": {
-    "@types/crypto-js": "^4.0.2",
     "@types/node": "^14.14.37",
     "prettier": "^2.4.1",
     "terser-webpack-plugin": "^5.2.4",
@@ -37,9 +36,9 @@
     "console-browserify": "^1.2.0",
     "constants-browserify": "^1.0.0",
     "crypto-browserify": "^3.12.0",
-    "crypto-js": "^4.1.1",
     "domain-browser": "^4.22.0",
     "events": "^3.3.0",
+    "hash-wasm": "^4.9.0",
     "hi-base32": "^0.5.1",
     "https-browserify": "^1.0.0",
     "lovefield-ts": "^0.7.0",

src/encrypt.ts

@@ -1,113 +1,125 @@
-import * as CryptoJS from "crypto-js";
 import * as base32 from "hi-base32";
-import {
+import { bufferToArrayBuffer, arrayBufferToBuffer } from "./misc";
-  bufferToArrayBuffer,
-  arrayBufferToBuffer,
-  arrayBufferToBase64,
-  base64ToArrayBuffer,
-} from "./misc";
 
 const DEFAULT_ITER = 10000;
 
-export const encryptWordArray = (
+const getKeyIVFromPassword = async (
-  wa: CryptoJS.lib.WordArray,
+  salt: Uint8Array,
   password: string,
   rounds: number = DEFAULT_ITER
 ) => {
-  const prefix = CryptoJS.enc.Utf8.parse("Salted__");
+  const k1 = await window.crypto.subtle.importKey(
-  const salt = CryptoJS.lib.WordArray.random(8);
+    "raw",
-  const derivedKey = CryptoJS.PBKDF2(password, salt, {
+    new TextEncoder().encode(password),
-    keySize: 32 + 16,
+    { name: "PBKDF2" },
-    iterations: rounds,
+    false,
-    hasher: CryptoJS.algo.SHA256,
+    ["deriveKey", "deriveBits"]
-  });
-  const key = CryptoJS.lib.WordArray.create(derivedKey.words.slice(0, 32 / 4));
-  const iv = CryptoJS.lib.WordArray.create(
-    derivedKey.words.slice(32 / 4, (32 + 16) / 4)
   );
-  const encrypted = CryptoJS.AES.encrypt(wa, key, { iv: iv }).ciphertext;
+
-  const res = CryptoJS.lib.WordArray.create()
+  const k2 = await window.crypto.subtle.deriveBits(
-    .concat(prefix)
+    {
-    .concat(salt)
+      name: "PBKDF2",
-    .concat(encrypted);
+      salt: salt,
-  return res;
+      iterations: rounds,
+      hash: "SHA-256",
+    },
+    k1,
+    256 + 128
+  );
+
+  return k2;
 };
 
-export const decryptWordArray = (
+export const encryptArrayBuffer = async (
-  wa: CryptoJS.lib.WordArray,
+  arrBuf: ArrayBuffer,
   password: string,
   rounds: number = DEFAULT_ITER
 ) => {
-  const prefix = CryptoJS.lib.WordArray.create(wa.words.slice(0, 8 / 4));
+  const salt = window.crypto.getRandomValues(new Uint8Array(8));
 
-  const salt = CryptoJS.lib.WordArray.create(
+  const derivedKey = await getKeyIVFromPassword(salt, password, rounds);
-    wa.words.slice(8 / 4, (8 + 8) / 4)
+  const key = derivedKey.slice(0, 32);
-  );
+  const iv = derivedKey.slice(32, 32 + 16);
-  const derivedKey = CryptoJS.PBKDF2(password, salt, {
+
-    keySize: 32 + 16,
+  const keyCrypt = await window.crypto.subtle.importKey(
-    iterations: rounds,
+    "raw",
-    hasher: CryptoJS.algo.SHA256,
-  });
-  const key = CryptoJS.lib.WordArray.create(derivedKey.words.slice(0, 32 / 4));
-  const iv = CryptoJS.lib.WordArray.create(
-    derivedKey.words.slice(32 / 4, 32 / 4 + 16 / 4)
-  );
-  const decrypted = CryptoJS.AES.decrypt(
-    CryptoJS.lib.CipherParams.create({
-      ciphertext: CryptoJS.lib.WordArray.create(wa.words.slice((8 + 8) / 4)),
-    }),
     key,
-    { iv: iv }
+    { name: "AES-CBC" },
+    false,
+    ["encrypt", "decrypt"]
   );
-  return decrypted;
+
+  const enc = (await window.crypto.subtle.encrypt(
+    { name: "AES-CBC", iv },
+    keyCrypt,
+    arrBuf
+  )) as ArrayBuffer;
+
+  const prefix = new TextEncoder().encode("Salted__");
+
+  const res = new Uint8Array(
+    [
+      ...prefix,
+      ...salt,
+      ...new Uint8Array(enc)
+    ]
+  );
+
+  return bufferToArrayBuffer(res);
 };
 
-export const encryptArrayBuffer = (
+export const decryptArrayBuffer = async (
   arrBuf: ArrayBuffer,
   password: string,
   rounds: number = DEFAULT_ITER
 ) => {
-  const b64 = arrayBufferToBase64(arrBuf);
+  const prefix = arrBuf.slice(0, 8);
-  const wa = CryptoJS.enc.Base64.parse(b64);
+  const salt = arrBuf.slice(8, 16);
-  const enc = encryptWordArray(wa, password, rounds);
+  const derivedKey = await getKeyIVFromPassword(
-  const resb64 = CryptoJS.enc.Base64.stringify(enc);
+    new Uint8Array(salt),
-  const res = base64ToArrayBuffer(resb64);
+    password,
-  return res;
+    rounds
+  );
+  const key = derivedKey.slice(0, 32);
+  const iv = derivedKey.slice(32, 32 + 16);
+
+  const keyCrypt = await window.crypto.subtle.importKey(
+    "raw",
+    key,
+    { name: "AES-CBC" },
+    false,
+    ["encrypt", "decrypt"]
+  );
+
+  const dec = (await window.crypto.subtle.decrypt(
+    { name: "AES-CBC", iv },
+    keyCrypt,
+    arrBuf.slice(16)
+  )) as ArrayBuffer;
+
+  return dec;
 };
 
-export const decryptArrayBuffer = (
+export const encryptStringToBase32 = async (
-  arrBuf: ArrayBuffer,
-  password: string,
-  rounds: number = DEFAULT_ITER
-) => {
-  const b64 = arrayBufferToBase64(arrBuf);
-  const wa = CryptoJS.enc.Base64.parse(b64);
-  const dec = decryptWordArray(wa, password, rounds);
-  const resb64 = CryptoJS.enc.Base64.stringify(dec);
-  const res = base64ToArrayBuffer(resb64);
-  return res;
-};
-
-export const encryptStringToBase32 = (
   text: string,
   password: string,
   rounds: number = DEFAULT_ITER
 ) => {
-  const wa = CryptoJS.enc.Utf8.parse(text);
+  return base32.encode(
-  const enc = encryptWordArray(wa, password, rounds);
+    await encryptArrayBuffer(new TextEncoder().encode(text), password, rounds)
-  const enctext = CryptoJS.enc.Base64.stringify(enc);
+  );
-  const res = base32.encode(base64ToArrayBuffer(enctext));
-  return res;
 };
 
-export const decryptBase32ToString = (
+export const decryptBase32ToString = async (
   text: string,
   password: string,
   rounds: number = DEFAULT_ITER
 ) => {
-  const enc = Buffer.from(base32.decode.asBytes(text)).toString("base64");
+  return (
-  const wa = CryptoJS.enc.Base64.parse(enc);
+    await decryptArrayBuffer(
-  const dec = decryptWordArray(wa, password, rounds);
+      bufferToArrayBuffer(Uint8Array.from(base32.decode.asBytes(text))),
-  const dectext = CryptoJS.enc.Utf8.stringify(dec);
+      password,
-  return dectext;
+      rounds
+    )
+  ).toString();
 };

src/main.ts

@@ -62,13 +62,6 @@ export default class SaveRemotePlugin extends Plugin {
       })
     );
 
-    // this.addRibbonIcon("dice", "Misc", async () => {
-    //   const a = this.app.vault.getAllLoadedFiles();
-    //   console.log(a);
-    //   const h = await getAllRecords(this.db);
-    //   console.log(h);
-    // });
-
     this.addRibbonIcon("switch", "Save Remote", async () => {
       if (this.syncStatus !== "idle") {
         new Notice("Save Remote already running!");
@@ -221,18 +214,6 @@ class SaveRemoteSettingTab extends PluginSettingTab {
             await this.plugin.saveSettings();
           })
       );
-    new Setting(containerEl)
-      .setName("password")
-      .setDesc("password")
-      .addText((text) =>
-        text
-          .setPlaceholder("")
-          .setValue(`${this.plugin.settings.password}`)
-          .onChange(async (value) => {
-            this.plugin.settings.password = value;
-            await this.plugin.saveSettings();
-          })
-      );
 
     new Setting(containerEl)
       .setName("s3BucketName")
@@ -246,5 +227,18 @@ class SaveRemoteSettingTab extends PluginSettingTab {
             await this.plugin.saveSettings();
           })
       );
+
+    new Setting(containerEl)
+      .setName("password")
+      .setDesc("password")
+      .addText((text) =>
+        text
+          .setPlaceholder("")
+          .setValue(`${this.plugin.settings.password}`)
+          .onChange(async (value) => {
+            this.plugin.settings.password = value;
+            await this.plugin.saveSettings();
+          })
+      );
   }
 }

src/misc.ts

@@ -46,7 +46,7 @@ export const mkdirpInVault = async (thePath: string, vault: Vault) => {
  * @param b Buffer
  * @returns ArrayBuffer
  */
-export const bufferToArrayBuffer = (b: Buffer) => {
+export const bufferToArrayBuffer = (b: Buffer | Uint8Array) => {
   return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
 };
 

src/s3.ts

@@ -109,7 +109,7 @@ export const uploadToRemote = async (
     const localContent = await vault.adapter.readBinary(fileOrFolderPath);
     let remoteContent = localContent;
     if (password !== "") {
-      remoteContent = encryptArrayBuffer(localContent, password);
+      remoteContent = await encryptArrayBuffer(localContent, password);
     }
     const body = arrayBufferToBuffer(remoteContent);
     await s3Client.send(
@@ -214,7 +214,7 @@ export const downloadFromRemote = async (
     );
     let localContent = remoteContent;
     if (password !== "") {
-      localContent = decryptArrayBuffer(remoteContent, password);
+      localContent = await decryptArrayBuffer(remoteContent, password);
     }
     await vault.adapter.writeBinary(fileOrFolderPath, localContent, {
       mtime: mtime,

src/sync.ts

@@ -62,7 +62,7 @@ export const ensembleMixedStates = async (
       const remoteEncryptedKey = entry.Key;
       let key = remoteEncryptedKey;
       if (password !== "") {
-        key = decryptBase32ToString(remoteEncryptedKey, password);
+        key = await decryptBase32ToString(remoteEncryptedKey, password);
       }
       const backwardMapping = await getSyncMetaMappingByRemoteKeyS3(
         db,
@@ -299,7 +299,7 @@ export const doActualSync = async (
       if (password !== "") {
         remoteEncryptedKey = state.remote_encrypted_key;
         if (remoteEncryptedKey === undefined || remoteEncryptedKey === "") {
-          remoteEncryptedKey = encryptStringToBase32(key, password);
+          remoteEncryptedKey = await encryptStringToBase32(key, password);
         }
       }
 
@@ -355,7 +355,13 @@ export const doActualSync = async (
           remoteEncryptedKey
         );
       } else if (state.decision === "delremote_clearhist") {
-        await deleteFromRemote(s3Client, s3Config, state.key);
+        await deleteFromRemote(
+          s3Client,
+          s3Config,
+          state.key,
+          password,
+          remoteEncryptedKey
+        );
         await clearDeleteRenameHistoryOfKey(db, state.key);
       } else if (state.decision === "upload") {
         const remoteObjMeta = await uploadToRemote(

versions.json

@@ -1,3 +1,3 @@
 {
-  "0.0.3": "0.12.15"
+  "0.0.6": "0.12.15"
 }

webpack.config.js

@@ -1,4 +1,5 @@
 const path = require("path");
+const webpack = require("webpack");
 const TerserPlugin = require("terser-webpack-plugin");
 
 module.exports = {
@@ -9,6 +10,16 @@ module.exports = {
     path: __dirname,
     libraryTarget: "commonjs",
   },
+  plugins: [
+    // Work around for Buffer is undefined:
+    // https://github.com/webpack/changelog-v5/issues/10
+    new webpack.ProvidePlugin({
+      Buffer: ["buffer", "Buffer"],
+    }),
+    new webpack.ProvidePlugin({
+      process: "process/browser",
+    }),
+  ],
   module: {
     rules: [
       {
@@ -20,7 +31,7 @@ module.exports = {
   },
   resolve: {
     extensions: [".tsx", ".ts", ".js"],
-    mainFields: ["module", "main"],
+    mainFields: ["browser", "module", "main"],
     fallback: {
       assert: require.resolve("assert"),
       buffer: require.resolve("buffer/"),