@secrecy/lib 1.0.0-dev.21 → 1.0.0-dev.25

package/__tests__/client/vFile.test.ts

@@ -0,0 +1,207 @@
+import { chris } from "./utils.js";
+import { setup } from "../../src/index.js";
+// import { Rights } from "../../src/zeus/index.js";
+// import WorkerMock from "../../src/worker/__mock__/sodium.worker";
+
+beforeAll(setup);
+
+beforeAll(async () => {
+  // await chris.emptyCloudTrash();
+  // await dauph.emptyCloudTrash();
+  // (self as Window & typeof globalThis).Worker = WorkerMock; // # Ca cest le bon type
+});
+
+describe("SecrecyClient - vFile", () => {
+  test("wrong vFile", async () => {
+    const vFile = await chris.vFile({
+      id: "id"
+    });
+    expect(vFile).toBeNull();
+  });
+
+  test("upload and delete vFile", async () => {
+    // //Root folder
+    // const rootFolder = await chris.folder();
+    // expect(rootFolder).not.toBeNull();
+    // if (!rootFolder) {
+    //   throw new Error("empty or undefined value: rootFolder");
+    // }
+    // const cloudFolderSub = rootFolder.subfolders.find(f => f.name === "cloud");
+    // expect(cloudFolderSub).not.toBeUndefined();
+    // if (!cloudFolderSub) {
+    //   throw new Error("empty or undefined value: cloudFolder");
+    // }
+    // const cloudFolder = await chris.folder({
+    //   id: cloudFolderSub.id
+    // });
+    // if (!cloudFolder) {
+    //   throw new Error("empty or undefined value: cloudFolder");
+    // }
+    // // const uploadFile = await chris.uploadFileInCloud({
+    // //   file: new Uint8Array([1, 2, 3, 4, 5]),
+    // //   name: "testChris",
+    // //   folderId: cloudFolder.id
+    // // });
+    // //look for vFile
+    // const vFileChris = await chris.vFile({ id: cloudFolder.vFiles[0].id });
+    // expect(vFileChris).not.toBeNull();
+    // if (!vFileChris) {
+    //   throw new Error("empty or undefined value: vFileChris");
+    // }
+    // //delete vFile
+    // const deleteVFile = await chris.deleteVFile({
+    //   fileId: vFileChris.id
+    // });
+    // expect(deleteVFile).toBe(true);
+    // //look for vFile deleted
+    // const deletedVFile = await chris.vFile({ id: cloudFolder.vFiles[0].id });
+    // expect(deletedVFile).not.toBeNull();
+    // if (!deletedVFile) {
+    //   throw new Error("empty or undefined value: deletedVFile");
+    // }
+    // expect(deletedVFile.deletedAt).not.toBeNull();
+    // //recover vFile
+    // const recoveredFile = await chris.recoverFile({
+    //   fileId: vFileChris.id
+    // });
+    // //look for vFile recovered
+    // expect(recoveredFile).toBe(true);
+    // const vFileChrisRecovered = await chris.vFile({
+    //   id: vFileChris.id
+    // });
+    // expect(vFileChrisRecovered).not.toBeNull();
+    // if (!vFileChrisRecovered) {
+    //   throw new Error("empty or undefined value: vFileChrisRecovered");
+    // }
+    // expect(vFileChrisRecovered.deletedAt).toBeNull();
+    // const deletedVFileToDeleteFromTrash = await chris.deleteVFile({
+    //   fileId: uploadFile.id
+    // });
+    // expect(deletedVFileToDeleteFromTrash).toBe(true);
+    // const deletedFromTrash = await chris.deleteVFileCloudTrash({
+    //   ids: [uploadFile.id]
+    // });
+    // expect(deletedFromTrash).toBe(true);
+  });
+
+  test("shareVFile", async () => {
+    // //Root folder
+    // const rootFolder = await chris.folder();
+    // expect(rootFolder).not.toBeNull();
+    // if (!rootFolder) {
+    //   throw new Error("empty or undefined value: rootFolder");
+    // }
+    // const cloudFolderSub = rootFolder.subfolders.find(f => f.name === "cloud");
+    // expect(cloudFolderSub).not.toBeUndefined();
+    // if (!cloudFolderSub) {
+    //   throw new Error("empty or undefined value: cloudFolder");
+    // }
+    // const cloudFolder = await chris.folder({
+    //   id: cloudFolderSub.id
+    // });
+    // if (!cloudFolder) {
+    //   throw new Error("empty or undefined value: cloudFolder");
+    // }
+    // // const uploadFile = await chris.uploadFileInCloud({
+    // //   file: new Uint8Array([1, 2, 3, 4, 5]),
+    // //   name: "testChris",
+    // //   folderId: cloudFolder.id
+    // // });
+    // //look for vFile
+    // const vFileChris = await chris.vFile({ id: cloudFolder.vFiles[0].id });
+    // expect(vFileChris).not.toBeNull();
+    // if (!vFileChris) {
+    //   throw new Error("empty or undefined value: vFileChris");
+    // }
+    // //share vFile
+    // const vFileSharing = await chris.shareVFile({
+    //   vFileId: vFileChris.id,
+    //   userId: dauphId,
+    //   rights: Rights.admin
+    // });
+    // expect(vFileSharing).toBe(true);
+    // //look for shared vFile
+    // const allVFilesShared = await chris.sharedVFiles();
+    // const vFileShared = allVFilesShared.find(f => f.id === vFileChris.id);
+    // if (!vFileShared) {
+    //   throw new Error("empty or undefined value: vFileShared");
+    // }
+    // expect(vFileShared.id).toBe(vFileChris.id);
+    // //look for vFile shared w/ me
+    // // const allVFilesSharedWithMe = await dauph.vFilesSharedWithMe();
+    // // expect(allVFilesSharedWithMe).not.toBeNull();
+    // // if (!allVFilesSharedWithMe) {
+    // // throw new Error("empty or undefined value: allVFilesSharedWithMe");
+    // // }
+    // // const vFileSharedWithMe = allVFilesSharedWithMe.find(
+    // //   f => f.id === vFileChris.id
+    // // );
+    // // if (!vFileSharedWithMe) {
+    // // throw new Error("empty or undefined value: vFileSharedWithMe");
+    // // }
+    // // expect(vFileSharedWithMe.id).toBe(vFileChris.id);
+    // //delete vFile sharing
+    // const deleteSharing = await chris.deleteVFileSharing({
+    //   vFileId: vFileChris.id,
+    //   userId: dauphId
+    // });
+    // expect(deleteSharing).toBe(true);
+    // const allDeletedShraring = await chris.sharedVFiles();
+    // const deletedSharing = allDeletedShraring.find(f => f.id === vFileChris.id);
+    // expect(deletedSharing).toBeUndefined();
+    // const deletedVFiles = await chris.deleteVFile({ fileId: uploadFile.id });
+    // expect(deletedVFiles).toBe(true);
+    // const deletedFromTrash = await chris.deleteVFileCloudTrash({
+    //   ids: [uploadFile.id]
+    // });
+    // expect(deletedFromTrash).toBe(true);
+  });
+
+  test("duplicate and update vFile", async () => {
+    // //Root folder
+    // const rootFolder = await chris.folder();
+    // expect(rootFolder).not.toBeNull();
+    // if (!rootFolder) {
+    //   throw new Error("empty or undefined value: rootFolder");
+    // }
+    // const cloudFolderSub = rootFolder.subfolders.find(f => f.name === "cloud");
+    // expect(cloudFolderSub).not.toBeUndefined();
+    // if (!cloudFolderSub) {
+    //   throw new Error("empty or undefined value: cloudFolder");
+    // }
+    // const cloudFolder = await chris.folder({
+    //   id: cloudFolderSub.id
+    // });
+    // if (!cloudFolder) {
+    //   throw new Error("empty or undefined value: cloudFolder");
+    // }
+    // //look for vFile
+    // const vFileChris = await chris.vFile({ id: cloudFolder.vFiles[0].id });
+    // expect(vFileChris).not.toBeNull();
+    // if (!vFileChris) {
+    //   throw new Error("empty or undefined value: vFileChris");
+    // }
+    // // duplicate vFile
+    // const duplicateVFile = await chris.duplicateVFile({
+    //   fileId: vFileChris.id
+    // });
+    // expect(duplicateVFile).toBe(true);
+    // const vFileDuplicated = cloudFolder.vFiles.find(
+    //   f => f.filename === vFileChris.filename
+    // );
+    // expect(vFileDuplicated).not.toBeUndefined();
+    // if (!vFileDuplicated) {
+    //   throw new Error("empty or undefined value: vFileDuplicated");
+    // }
+    // //delete duplicated vFile
+    // const deleteDuplicatedVFile = await chris.deleteVFile({
+    //   fileId: vFileDuplicated.id
+    // });
+    // expect(deleteDuplicatedVFile).toBe(true);
+    // //delete duplicated vFile
+    // const deleteCloudTrashDuplicatedVFile = await chris.deleteVFileCloudTrash({
+    //   ids: [vFileDuplicated.id]
+    // });
+    // expect(deleteCloudTrashDuplicatedVFile).toBe(true);
+  });
+});

package/__tests__/index.test.ts

@@ -0,0 +1,171 @@
+import type { KeyPair } from "../src/crypto/index.js";
+import {
+  encryptCryptoBox,
+  decryptCryptoBox,
+  encryptAnonymous,
+  decryptAnonymous,
+  encryptSecretBox,
+  decryptSecretBox,
+  generateSecretBoxKey,
+  generateCryptoBoxKeyPair
+} from "../src/crypto/index.js";
+import {
+  secretstreamKeygen,
+  encryptSecretstream,
+  decryptSecretstream
+} from "../src/crypto/file.js";
+import { compress, uncompress } from "../src/minify/index.js";
+import { sodium, setup } from "../src/sodium.js";
+
+function random(seed: number): {
+  seed: (s: number) => void;
+  nextInt: () => number;
+  nextFloat: () => number;
+} {
+  function pSeed(s: number): void {
+    if ((seed = (s | 0) % 2147483647) <= 0) {
+      seed += 2147483646;
+    }
+  }
+
+  function pNextInt(): number {
+    return (seed = (seed * 48271) % 2147483647);
+  }
+
+  function pNextFLoat(): number {
+    return (pNextInt() - 1) / 2147483646;
+  }
+
+  pSeed(seed);
+
+  return {
+    seed: pSeed,
+    nextInt: pNextInt,
+    nextFloat: pNextFLoat
+  };
+}
+
+const { nextInt } = random(Date.now());
+
+const randomArray = (size: number, random = true): Uint8Array =>
+  new Uint8Array([...Array(size).keys()].map(() => (random ? nextInt() : 0)));
+
+beforeAll(setup);
+
+let keyPair: KeyPair;
+let random1mo: Uint8Array;
+// let random10mo: Uint8Array;
+// let random100mo: Uint8Array;
+// let random1go: Uint8Array;
+// let random2go: Uint8Array;
+// let random4go: Uint8Array;
+
+const ONE_MO = 1_000_000;
+
+beforeAll(() => {
+  keyPair = generateCryptoBoxKeyPair();
+  random1mo = randomArray(ONE_MO);
+  // random10mo = randomArray(ONE_MO * 10);
+  // random100mo = randombytes_buf(ONE_MO * 100);
+  // random1go = randombytes_buf(ONE_MO * 1024);
+  // random2go = randombytes_buf(ONE_MO * 2048);
+  // random4go = randombytes_buf(ONE_MO * 4096);
+});
+
+describe("lz4", () => {
+  test("compress/decompress", () => {
+    const data = randomArray(ONE_MO, false);
+    const compressed = compress(data);
+    // const l = data.byteLength;
+    // const bl = compressed.byteLength;
+    // console.log(
+    //   `original: ${l}, compressed: ${bl}, ${((bl / l) * 100).toFixed(2)}%`
+    // );
+    const dst = uncompress(compressed);
+    expect(data).toEqual(dst);
+  });
+  test("impossible compress/decompress", () => {
+    const data = new Uint8Array([0]);
+    const compressed = compress(data);
+    expect(compressed).toEqual(new Uint8Array([0, 0]));
+    const dst = uncompress(compressed);
+    expect(data).toEqual(dst);
+  });
+});
+
+test("two encrypt with same keypair are different", () => {
+  const crypt1 = encryptCryptoBox(
+    random1mo,
+    keyPair.publicKey,
+    keyPair.privateKey
+  );
+  const crypt2 = encryptCryptoBox(
+    random1mo,
+    keyPair.publicKey,
+    keyPair.privateKey
+  );
+  expect(crypt2).not.toEqual(crypt1);
+});
+
+describe("encrypt file benchmark", () => {
+  // test("100mo", () => {
+  //   encryptFile(random100mo, key);
+  // });
+  // // test("1go", () => {
+  // //   encryptFile(random1go, key);
+  // // });
+  // // test("2go", () => {
+  // //   encryptFile(random2go, key);
+  // // });
+  // // test("4go", () => {
+  // //   encryptFile(random4go, key);
+  // // });
+  test("secretstream", async () => {
+    const key = secretstreamKeygen();
+    const { data: crypted } = await encryptSecretstream(key, random1mo);
+    const decrypted = await decryptSecretstream(key, crypted);
+    expect(random1mo).toEqual(decrypted);
+  });
+  test("decrypt crypto box", () => {
+    const { privateKey } = generateCryptoBoxKeyPair();
+    const privateKeyEncrypted = encryptCryptoBox(
+      sodium.from_hex(privateKey),
+      keyPair.publicKey,
+      keyPair.privateKey
+    );
+    const priv = decryptCryptoBox(
+      privateKeyEncrypted,
+      keyPair.publicKey,
+      keyPair.privateKey
+    );
+    expect(sodium.to_hex(priv)).toEqual(privateKey);
+  });
+  test("send crypto box", () => {
+    const alice = generateCryptoBoxKeyPair();
+    const bob = generateCryptoBoxKeyPair();
+    const data = new Uint8Array([1, 2, 3, 4, 5]);
+    const encryptedMessage = encryptCryptoBox(
+      data,
+      bob.publicKey,
+      alice.privateKey
+    );
+    const decryptedMessage = decryptCryptoBox(
+      encryptedMessage,
+      alice.publicKey,
+      bob.privateKey
+    );
+    expect(decryptedMessage).toEqual(data);
+  });
+  test("anonymous to recipient", () => {
+    const alice = generateCryptoBoxKeyPair();
+    const encryptedMessage = encryptAnonymous(random1mo, alice.publicKey);
+    const decryptedMessage = decryptAnonymous(encryptedMessage, alice);
+    expect(decryptedMessage).toEqual(random1mo);
+  });
+  test("secretbox", () => {
+    const key = generateSecretBoxKey();
+    const encryptedMessage = encryptSecretBox(random1mo, key);
+    const decryptedMessage = decryptSecretBox(encryptedMessage, key);
+    expect(decryptedMessage).toEqual(random1mo);
+  });
+});

package/commitlint.config.cjs

@@ -0,0 +1,3 @@
+module.exports = {
+  extends: ["@commitlint/config-conventional"]
+};