bump to 0.0.7

.github/workflows/auto-build.yml

@@ -5,9 +5,9 @@ name: BuildCI
 
 on:
   push:
-    branches: [master, enc]
+    branches: [master]
   pull_request:
-    branches: [master, enc]
+    branches: [master]
 
 jobs:
   build:
@@ -25,6 +25,7 @@ jobs:
         with:
           node-version: ${{ matrix.node-version }}
       - run: npm install
+      - run: npm test
       - run: npm run build
       - uses: actions/upload-artifact@v2
         with:

manifest.json

@@ -1,7 +1,7 @@
 {
   "id": "obsdian-save-remote",
   "name": "Save remote",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "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,22 +1,29 @@
 {
   "name": "obsidian-save-remote",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "This is yet another sync plugin for Obsidian app.",
   "scripts": {
     "dev": "webpack --mode development --watch",
     "build": "webpack --mode production",
     "format": "npx prettier --write .",
-    "clean": "npx rimraf main.js"
+    "clean": "npx rimraf main.js",
+    "test": "env TS_NODE_COMPILER_OPTIONS='{\"module\": \"commonjs\" }' mocha -r ts-node/register 'tests/**/*.ts'"
   },
   "source": "main.ts",
   "keywords": [],
   "author": "",
   "license": "Apache-2.0",
   "devDependencies": {
+    "@types/chai": "^4.2.22",
+    "@types/mime-types": "^2.1.1",
+    "@types/mocha": "^9.0.0",
     "@types/node": "^14.14.37",
+    "chai": "^4.3.4",
+    "mocha": "^9.1.3",
     "prettier": "^2.4.1",
     "terser-webpack-plugin": "^5.2.4",
     "ts-loader": "^9.2.6",
+    "ts-node": "^10.4.0",
     "tslib": "^2.2.0",
     "typescript": "^4.4.4",
     "webdav-server": "^2.6.2",
@@ -26,38 +33,18 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.37.0",
     "@aws-sdk/signature-v4-crt": "^3.37.0",
-    "@types/mime-types": "^2.1.1",
     "acorn": "^8.5.0",
-    "assert": "^2.0.0",
     "aws-crt": "^1.10.1",
-    "browserify-zlib": "^0.2.0",
     "buffer": "^6.0.3",
     "codemirror": "^5.63.1",
-    "console-browserify": "^1.2.0",
-    "constants-browserify": "^1.0.0",
-    "crypto-browserify": "^3.12.0",
-    "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",
     "mime-types": "^2.1.33",
     "obsidian": "^0.12.0",
-    "os-browserify": "^0.3.0",
     "path-browserify": "^1.0.1",
     "process": "^0.11.10",
-    "punycode": "^2.1.1",
-    "querystring-es3": "^0.2.1",
+    "rfc4648": "^1.5.0",
     "rimraf": "^3.0.2",
     "stream-browserify": "^3.0.0",
-    "stream-http": "^3.2.0",
-    "string_decoder": "^1.3.0",
-    "timers-browserify": "^2.0.12",
-    "tty-browserify": "0.0.1",
-    "url": "^0.11.0",
-    "util": "^0.12.4",
-    "vm-browserify": "^1.1.2",
     "webdav": "^4.7.0",
     "webdav-fs": "^4.0.0"
   }

src/encrypt.ts

@@ -1,67 +1,76 @@
-import { randomBytes, createDecipheriv, createCipheriv } from "crypto";
-import { pbkdf2, createSHA256 } from "hash-wasm";
-import { promisify } from "util";
-import * as base32 from "hi-base32";
-import { bufferToArrayBuffer, arrayBufferToBuffer } from "./misc";
+import { base32, base64 } from "rfc4648";
+import {
+  bufferToArrayBuffer,
+  arrayBufferToBuffer,
+  hexStringToTypedArray,
+  arrayBufferToHex,
+} from "./misc";
 
 const DEFAULT_ITER = 10000;
 
-export const encryptBuffer = async (
-  buf: Buffer,
+const getKeyIVFromPassword = async (
+  salt: Uint8Array,
   password: string,
   rounds: number = DEFAULT_ITER
 ) => {
-  const salt = await promisify(randomBytes)(8);
-  const derivedKey = await pbkdf2({
-    password: password,
-    salt: salt,
-    iterations: rounds,
-    hashLength: 32 + 16,
-    hashFunction: createSHA256(),
-    outputType: "binary",
-  });
-  const key = derivedKey.slice(0, 32);
-  const iv = derivedKey.slice(32, 32 + 16);
-  const cipher = createCipheriv("aes-256-cbc", key, iv);
-  cipher.write(buf);
-  cipher.end();
-  const encrypted = cipher.read();
-  const res = Buffer.concat([Buffer.from("Salted__"), salt, encrypted]);
-  return res;
-};
+  const k1 = await window.crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(password),
+    { name: "PBKDF2" },
+    false,
+    ["deriveKey", "deriveBits"]
+  );
 
-export const decryptBuffer = async (
-  buf: Buffer,
-  password: string,
-  rounds: number = DEFAULT_ITER
-) => {
-  const prefix = buf.slice(0, 8);
-  const salt = buf.slice(8, 16);
-  const derivedKey = await pbkdf2({
-    password: password,
+  const k2 = await window.crypto.subtle.deriveBits(
+    {
+      name: "PBKDF2",
       salt: salt,
       iterations: rounds,
-    hashLength: 32 + 16,
-    hashFunction: createSHA256(),
-    outputType: "binary",
-  });
-  const key = derivedKey.slice(0, 32);
-  const iv = derivedKey.slice(32, 32 + 16);
-  const decipher = createDecipheriv("aes-256-cbc", key, iv);
-  decipher.write(buf.slice(16));
-  decipher.end();
-  const decrypted = decipher.read();
-  return decrypted as Buffer;
+      hash: "SHA-256",
+    },
+    k1,
+    256 + 128
+  );
+
+  return k2;
 };
 
 export const encryptArrayBuffer = async (
   arrBuf: ArrayBuffer,
   password: string,
-  rounds: number = DEFAULT_ITER
+  rounds: number = DEFAULT_ITER,
+  saltHex: string = ""
 ) => {
-  return bufferToArrayBuffer(
-    await encryptBuffer(arrayBufferToBuffer(arrBuf), password, rounds)
+  let salt: Uint8Array;
+  if (saltHex !== "") {
+    salt = hexStringToTypedArray(saltHex);
+  } else {
+    salt = window.crypto.getRandomValues(new Uint8Array(8));
+  }
+
+  const derivedKey = await getKeyIVFromPassword(salt, password, 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 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 decryptArrayBuffer = async (
@@ -69,19 +78,46 @@ export const decryptArrayBuffer = async (
   password: string,
   rounds: number = DEFAULT_ITER
 ) => {
-  return bufferToArrayBuffer(
-    await decryptBuffer(arrayBufferToBuffer(arrBuf), password, rounds)
+  const prefix = arrBuf.slice(0, 8);
+  const salt = arrBuf.slice(8, 16);
+  const derivedKey = await getKeyIVFromPassword(
+    new Uint8Array(salt),
+    password,
+    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 encryptStringToBase32 = async (
   text: string,
   password: string,
-  rounds: number = DEFAULT_ITER
+  rounds: number = DEFAULT_ITER,
+  saltHex: string = ""
 ) => {
-  return base32.encode(
-    await encryptBuffer(Buffer.from(text), password, rounds)
+  const enc = await encryptArrayBuffer(
+    bufferToArrayBuffer(new TextEncoder().encode(text)),
+    password,
+    rounds,
+    saltHex
   );
+  return base32.stringify(new Uint8Array(enc));
 };
 
 export const decryptBase32ToString = async (
@@ -89,11 +125,11 @@ export const decryptBase32ToString = async (
   password: string,
   rounds: number = DEFAULT_ITER
 ) => {
-  return (
-    await decryptBuffer(
-      Buffer.from(base32.decode.asBytes(text)),
+  return new TextDecoder().decode(
+    await decryptArrayBuffer(
+      bufferToArrayBuffer(base32.parse(text)),
       password,
       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

@@ -1,6 +1,8 @@
 import { Vault } from "obsidian";
 import * as path from "path";
 
+import { base32 } from "rfc4648";
+
 export type SUPPORTED_SERVICES_TYPE = "s3" | "webdav" | "ftp";
 
 export const ignoreHiddenFiles = (item: string) => {
@@ -46,7 +48,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);
 };
 
@@ -63,6 +65,27 @@ export const arrayBufferToBase64 = (b: ArrayBuffer) => {
   return arrayBufferToBuffer(b).toString("base64");
 };
 
+export const arrayBufferToHex = (b: ArrayBuffer) => {
+  return arrayBufferToBuffer(b).toString("hex");
+};
+
 export const base64ToArrayBuffer = (b64text: string) => {
   return bufferToArrayBuffer(Buffer.from(b64text, "base64"));
 };
+
+/**
+ * https://stackoverflow.com/questions/43131242
+ * @param hex
+ * @returns
+ */
+export const hexStringToTypedArray = (hex: string) => {
+  return new Uint8Array(
+    hex.match(/[\da-f]{2}/gi).map(function (h) {
+      return parseInt(h, 16);
+    })
+  );
+};
+
+export const base64ToBase32 = (a: string) => {
+  return base32.stringify(Buffer.from(a, "base64"));
+};

src/sync.ts

@@ -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(

tests/sometext.txt

@@ -0,0 +1 @@
+A secret text 你好世界

tests/test-encrypt.ts

@@ -0,0 +1,55 @@
+import * as fs from "fs";
+import { expect } from "chai";
+import { base64ToBase32 } from "../src/misc";
+import {
+  decryptBase32ToString,
+  encryptStringToBase32,
+} from "../src/encrypt";
+
+describe("Encryption tests", () => {
+  beforeEach(function () {
+    global.window = {
+      crypto: require("crypto").webcrypto,
+    } as any;
+  });
+
+  it("should encrypt string", async () => {
+    const k = "dkjdhkfhdkjgsdklxxd";
+    const password = "hey";
+    expect(await encryptStringToBase32(k, password)).to.not.equal(k);
+  });
+
+  it("should encrypt and decrypt string and get the same result returned", async () => {
+    const k = "jfkkjkjbce7983ycdeknkkjckooAIUHIDIBIE((*BII)njD/d/dd/d/sjxhux";
+    const password = "hfiuibec989###oiu982bj1`";
+    const enc = await encryptStringToBase32(k, password);
+    console.log(enc);
+    const dec = await decryptBase32ToString(enc, password);
+    console.log(dec);
+    expect(dec).equal(k);
+  });
+
+  it("should encrypt and get the same result as openssl", async () => {
+    const fileContent = (
+      await fs.readFileSync(__dirname + "/sometext.txt")
+    ).toString("utf-8");
+    const password = "somepassword";
+    const saltHex = "8302F586FAB491EC";
+    const enc = await encryptStringToBase32(
+      fileContent,
+      password,
+      undefined,
+      saltHex
+    );
+
+    // two command returns same result:
+    // cat ./sometext.txt | openssl enc -p -aes-256-cbc -S 8302F586FAB491EC -pbkdf2 -iter 10000 -base64 -pass pass:somepassword
+    // openssl enc -p -aes-256-cbc -S 8302F586FAB491EC -pbkdf2 -iter 10000 -base64 -pass pass:somepassword -in ./sometext.txt
+    const opensslBase64Res =
+      "U2FsdGVkX1+DAvWG+rSR7MSa+yJav1zCE7SSXiBooqwI5Q+LMpIthpk/pXkLj+25";
+    // we output base32, so we need some transformation
+    const opensslBase32Res = base64ToBase32(opensslBase64Res);
+
+    expect(enc).equal(opensslBase32Res);
+  });
+});

versions.json

@@ -1,3 +1,3 @@
 {
-  "0.0.5": "0.12.15"
+  "0.0.7": "0.12.15"
 }

webpack.config.js

@@ -33,29 +33,29 @@ module.exports = {
     extensions: [".tsx", ".ts", ".js"],
     mainFields: ["browser", "module", "main"],
     fallback: {
-      assert: require.resolve("assert"),
-      buffer: require.resolve("buffer/"),
-      console: require.resolve("console-browserify"),
-      constants: require.resolve("constants-browserify"),
-      crypto: require.resolve("crypto-browserify"),
-      domain: require.resolve("domain-browser"),
-      events: require.resolve("events"),
-      http: require.resolve("stream-http"),
-      https: require.resolve("https-browserify"),
-      os: require.resolve("os-browserify/browser"),
+      // assert: require.resolve("assert"),
+      // buffer: require.resolve("buffer/"),
+      // console: require.resolve("console-browserify"),
+      // constants: require.resolve("constants-browserify"),
+      // crypto: require.resolve("crypto-browserify"),
+      // domain: require.resolve("domain-browser"),
+      // events: require.resolve("events"),
+      // http: require.resolve("stream-http"),
+      // https: require.resolve("https-browserify"),
+      // os: require.resolve("os-browserify/browser"),
       path: require.resolve("path-browserify"),
-      punycode: require.resolve("punycode"),
+      // punycode: require.resolve("punycode"),
       process: require.resolve("process/browser"),
-      querystring: require.resolve("querystring-es3"),
+      // querystring: require.resolve("querystring-es3"),
       stream: require.resolve("stream-browserify"),
-      string_decoder: require.resolve("string_decoder"),
-      sys: require.resolve("util"),
-      timers: require.resolve("timers-browserify"),
-      tty: require.resolve("tty-browserify"),
-      url: require.resolve("url"),
-      util: require.resolve("util"),
-      vm: require.resolve("vm-browserify"),
-      zlib: require.resolve("browserify-zlib"),
+      // string_decoder: require.resolve("string_decoder"),
+      // sys: require.resolve("util"),
+      // timers: require.resolve("timers-browserify"),
+      // tty: require.resolve("tty-browserify"),
+      // url: require.resolve("url"),
+      // util: require.resolve("util"),
+      // vm: require.resolve("vm-browserify"),
+      // zlib: require.resolve("browserify-zlib"),
     },
   },
   externals: {