@secrecy/lib 1.86.2-fix-md5.1 → 1.86.3

package/dist/lib/base-client.js

@@ -1,4 +1,4 @@
-import { usersCache } from './cache.js';
+import { usersCache, clearAllCaches } from './cache.js';
 import { getStorage } from './client/storage.js';
 import { createTRPCClient, } from './client.js';
 import { getPreferedEmail } from './utils.js';
@@ -46,15 +46,16 @@ export class BaseClient {
                 BaseClient.getBaseClient({
                     session: opts.session,
                     apiUrl: this.secrecyUrls.api,
+                    timeoutMs: opts.timeoutMs,
                     onAccessDenied: async () => {
-                        console.log('[BASE_CLIENT - BEFORE] - Access denied');
                         await opts.onAccessDenied?.();
-                        console.log('[BASE_CLIENT - AFTER] - Access denied');
                         try {
                             await this.logout();
                         }
                         finally {
-                            location.reload();
+                            if (opts.reloadOnAccessDenied ?? true) {
+                                location.reload();
+                            }
                         }
                     },
                 });
@@ -141,6 +142,6 @@ export class BaseClient {
         session.identities.clear();
         session.keyPairs.clear();
         session.userAppSession.clear();
-        usersCache.clear();
+        clearAllCaches();
     };
 }

package/dist/lib/cache.js

@@ -1,8 +1,9 @@
 import { LRUCache } from 'lru-cache';
 import { gigaToBytes } from './utils.js';
-export const dataCache = new Map();
-export const nodesCache = new Map();
-export const nodesEncryptionCache = new Map();
+const boundedCacheOpts = { max: 5_000, ttl: 5 * 60 * 1000 };
+export const dataCache = new LRUCache(boundedCacheOpts);
+export const nodesCache = new LRUCache(boundedCacheOpts);
+export const nodesEncryptionCache = new LRUCache(boundedCacheOpts);
 export const getNodeForEncryptionFromCache = (id) => {
     if (nodesEncryptionCache.has(id)) {
         return nodesEncryptionCache.get(id);
@@ -12,8 +13,8 @@ export const getNodeForEncryptionFromCache = (id) => {
     }
     return undefined;
 };
-export const usersCache = new Map();
-export const publicKeysCache = new Map();
+export const usersCache = new LRUCache(boundedCacheOpts);
+export const publicKeysCache = new LRUCache({ max: 10_000 });
 export const dataContentCache = new LRUCache({
     max: 500,
     maxSize: gigaToBytes(0.5),
@@ -21,3 +22,11 @@ export const dataContentCache = new LRUCache({
         return value.data.byteLength;
     },
 });
+export function clearAllCaches() {
+    dataCache.clear();
+    nodesCache.clear();
+    nodesEncryptionCache.clear();
+    usersCache.clear();
+    publicKeysCache.clear();
+    dataContentCache.clear();
+}

package/dist/lib/client/SecrecyCloudClient.js

@@ -702,10 +702,8 @@ export class SecrecyCloudClient {
         const src = key
             ? await decrypt(key, encryptedContent, progressDecrypt, signal)
             : encryptedContent;
-        // Encrypted data is authenticated by the stream: only public data has an md5.
-        if (!key &&
-            dataContent.md5 !== null &&
-            (await md5(src)) !== dataContent.md5) {
+        const md5Content = await md5(src);
+        if (md5Content !== dataContent.md5) {
             throw new Error(`Content does not match`);
         }
         const decompressed = decompress(src);

package/dist/lib/client/SecrecyMailClient.js

@@ -31,8 +31,13 @@ export class SecrecyMailClient {
         })));
     }
     async create(data, customMessage) {
-        const mail = await this.createDraft(data);
-        const isSent = await this.sendDraft(mail.mailIntegrityId, customMessage);
+        const { customMessage: embeddedCustomMessage, ...mailData } = data;
+        const resolvedCustomMessage = customMessage ?? embeddedCustomMessage;
+        const mail = await this.createDraft(mailData);
+        const isSent = await this.sendDraft({
+            draftId: mail.mailIntegrityId,
+            customMessage: resolvedCustomMessage,
+        });
         if (!isSent) {
             throw new Error('The mail does not sent!');
         }
@@ -53,7 +58,8 @@ export class SecrecyMailClient {
         }));
         return waitingReceivedMailsWithIds;
     }
-    async updateDraft(draftId, { body, subject, senderFiles, recipients, replyToId }) {
+    async updateDraft(arg, args) {
+        const { draftId, body, subject, senderFiles, recipients, replyToId, } = typeof arg === 'string' ? { draftId: arg, ...args } : arg;
         const drafts = await this.draftMails({});
         const draft = drafts.find((d) => d.mailIntegrityId === draftId);
         if (draft === undefined) {
@@ -124,7 +130,8 @@ export class SecrecyMailClient {
         });
         return isDeleted;
     }
-    async sendDraft(draftId, customMessage) {
+    async sendDraft(arg, customMessage) {
+        const { draftId, customMessage: resolvedCustomMessage } = typeof arg === 'string' ? { draftId: arg, customMessage } : arg;
         const drafts = await this.draftMails({});
         const draft = drafts.find((d) => d.mailIntegrityId === draftId);
         if (draft === undefined) {
@@ -157,7 +164,7 @@ export class SecrecyMailClient {
             temporaryRecipients,
             recipients,
             id: draft.mailIntegrityId,
-            customMessage: customMessage ?? null,
+            customMessage: resolvedCustomMessage ?? null,
         });
         return isSent;
     }

package/dist/lib/client/data-link.js

@@ -1,13 +1,14 @@
 import z from 'zod';
 import { buildBytesFromDataLink } from '../crypto/domain';
 import { sodium } from '../sodium';
-import { decryptKeyWithPassword } from '../crypto/helpers';
+import { derivePassword } from '../crypto/helpers';
+import { decryptSecretBox } from '../crypto';
 import { decrypt } from '../worker/sodium';
+import { md5 } from '../worker/md5';
 import { decompress } from '../minify';
 const downloadDataLinkS3Schema = z.object({
     name: z.string(),
-    // Only for unencrypted and legacy encrypted data.
-    md5: z.string().nullable(),
+    md5: z.string(),
     md5Encrypted: z.string().nullable(),
     size: z.coerce.bigint().gte(0n),
     parts: z.array(z.object({ order: z.number(), md5: z.string(), contentUrl: z.string() })),
@@ -16,8 +17,7 @@ const downloadDataLinkS3Schema = z.object({
 });
 const downloadDataLinkLiteSchema = z.object({
     name: z.string(),
-    // Only for unencrypted and legacy encrypted data.
-    md5: z.string().nullable(),
+    md5: z.string(),
     md5Encrypted: z.string().nullable(),
     size: z.coerce.bigint().gte(0n),
     bytes: z.string(),
@@ -69,8 +69,14 @@ export async function downloadDataFromLink(opts) {
         throw new Error('Unable to read encrypted data without password!');
     }
     try {
-        const decryptedSharingDataKey = decryptKeyWithPassword(sodium.from_hex(opts.crypto.key), opts.crypto.password);
+        const salt = sodium.crypto_generichash(sodium.crypto_pwhash_SALTBYTES, opts.crypto.password + dataLink.md5);
+        const derivedPassword = derivePassword(opts.crypto.password, salt);
+        const decryptedSharingDataKey = decryptSecretBox(sodium.from_hex(opts.crypto.key), derivedPassword);
         const decryptedBytes = await decrypt(decryptedSharingDataKey, bytes, opts.decryptProgress, opts.signal);
+        const md5Content = await md5(decryptedBytes);
+        if (md5Content !== dataLink.md5) {
+            throw new Error(`Content does not match`);
+        }
         return decompress(decryptedBytes);
     }
     catch (err) {

package/dist/lib/client/helpers.js

@@ -2,16 +2,26 @@ import { SecrecyClient } from './index.js';
 import { popup } from '../utils/popup-tools.js';
 import { secrecyUserApp } from './types/index.js';
 import { getStorage } from './storage.js';
+import { setup } from '../sodium.js';
+export function assertBrowser(fn) {
+    if (typeof window === 'undefined') {
+        const err = {
+            name: 'ClientError',
+            code: 'SERVER_ENVIRONMENT',
+            message: `${fn}() can only run in a browser. On Next.js, call it from a "use client" component, or via dynamic(..., { ssr: false }).`,
+        };
+        throw err;
+    }
+}
 export function parseInfos() {
+    assertBrowser('parseInfos');
     if (window.location.hash === '') {
         return null;
     }
-    const hash = window.location.hash.substr(1);
+    const hash = window.location.hash.slice(1);
     try {
         const res = JSON.parse(atob(hash));
-        // Replace (not push) the entry: the fragment holds the private keys and
-        // must not stay in the browser history.
-        window.history.replaceState(window.history.state, '', window.location.pathname + window.location.search);
+        history.replaceState(null, '', window.location.pathname + window.location.search);
         const data = secrecyUserApp.safeParse(res);
         return data.success ? data.data : null;
     }
@@ -20,6 +30,7 @@ export function parseInfos() {
     }
 }
 export function getSecrecyClient(opts = {}) {
+    assertBrowser('getSecrecyClient');
     const storage = getStorage(opts.session);
     const infos = parseInfos();
     if (infos !== null) {
@@ -51,6 +62,7 @@ export function getSecrecyClient(opts = {}) {
     return null;
 }
 export async function login({ appId, context, path, redirect, scopes, backPath, session, secrecyUrls, forceLogin, }) {
+    assertBrowser('login');
     return await new Promise(async (resolve, reject) => {
         const appUrl = window.location.origin;
         const client = getSecrecyClient({ session, secrecyUrls });
@@ -131,3 +143,21 @@ export async function login({ appId, context, path, redirect, scopes, backPath,
         }
     });
 }
+/**
+ * Single async entry point: runs `setup()`, reuses an existing session if
+ * one is found, and falls back to `login()` otherwise. Equivalent to
+ * `await setup()` + `getSecrecyClient()` + `login()`, without having to
+ * juggle the sync/async mismatch between them.
+ */
+export async function initSecrecy(opts) {
+    assertBrowser('initSecrecy');
+    await setup();
+    const existing = getSecrecyClient({
+        session: opts.session,
+        secrecyUrls: opts.secrecyUrls,
+    });
+    if (existing !== null) {
+        return existing;
+    }
+    return await login(opts);
+}

package/dist/lib/client/index.js

@@ -2,8 +2,7 @@ import { BaseClient } from '../base-client.js';
 import { SecrecyCloudClient } from './SecrecyCloudClient.js';
 import { SecrecyMailClient } from './SecrecyMailClient.js';
 import { SecrecyAppClient } from './SecrecyAppClient.js';
-import { nodesCache, dataCache, publicKeysCache } from '../cache.js';
-import { SecrecyDbClient } from './SecrecyDbClient.js';
+import { clearAllCaches } from '../cache.js';
 import { SecrecyWalletClient } from './SecrecyWalletClient.js';
 import { SecrecyPayClient } from './SecrecyPayClient.js';
 import { SecrecyUserClient } from './SecrecyUserClient.js';
@@ -20,9 +19,10 @@ export class SecrecyClient extends BaseClient {
     cloud;
     mail;
     app;
-    db;
     organization;
+    /** @experimental Susceptible de changer sans version majeure. */
     wallet;
+    /** @experimental Susceptible de changer sans version majeure. */
     pay;
     user;
     pseudonym;
@@ -33,8 +33,9 @@ export class SecrecyClient extends BaseClient {
             session: opts.uaSession,
             secrecyUrls: opts.secrecyUrls,
             apiClient: opts.apiClient,
+            timeoutMs: opts.timeoutMs,
+            reloadOnAccessDenied: opts.reloadOnAccessDenied,
             onAccessDenied: async () => {
-                console.log('[CLIENT] - Access denied');
                 try {
                     await this.logout();
                 }
@@ -53,7 +54,6 @@ export class SecrecyClient extends BaseClient {
         this.cloud = new SecrecyCloudClient(this);
         this.mail = new SecrecyMailClient(this);
         this.app = new SecrecyAppClient(opts.uaJwt, this);
-        this.db = new SecrecyDbClient(this);
         this.organization = new SecrecyOrganizationClient(this);
         this.wallet = new SecrecyWalletClient(this);
         this.pay = new SecrecyPayClient(this);
@@ -104,9 +104,7 @@ export class SecrecyClient extends BaseClient {
         });
     }
     async logout(sessionId) {
-        nodesCache.clear();
-        dataCache.clear();
-        publicKeysCache.clear();
+        clearAllCaches();
         await super.logout(sessionId);
     }
 }

package/dist/lib/client/upload.js

@@ -8,8 +8,8 @@ import { chunks, enumerate } from '../utils/array.js';
 import { getTrpcGuestClient, } from '../client.js';
 import axios from 'axios';
 import { encryptDataAndKey } from '../crypto/domain.js';
-import { encryptKeyWithPassword, generatePassword } from '../crypto/helpers.js';
-import { decryptCryptoBox } from '../crypto/index.js';
+import { derivePassword, generatePassword } from '../crypto/helpers.js';
+import { decryptCryptoBox, encryptSecretBox } from '../crypto/index.js';
 export async function uploadData({ storageType, data, password, forcePassword = false, encrypted = true, encryptProgress, uploadProgress, signal, meta, currentIdentity, keyPairs, apiClient, }) {
     if (!encrypted && (password || forcePassword)) {
         throw new Error('Cannot share unencrypted data with a password!');
@@ -40,10 +40,7 @@ export async function uploadData({ storageType, data, password, forcePassword =
         throw new Error('Cold storage is only for logged users!');
     }
     const compressed = encrypted ? compress(dataBuffer) : dataBuffer;
-    // Only unencrypted (public) data sends the md5 of its content, computed in
-    // the requests below: for encrypted data it would let the server
-    // fingerprint the plaintext.
-    let { encryptedData, encryptedDataKey, dataKey, md5Encrypted } = encrypted
+    let { encryptedData, encryptedDataKey, dataKey, md5Data, md5Encrypted } = encrypted
         ? await encryptDataAndKey({
             data: compressed,
             progress: encryptProgress,
@@ -55,6 +52,7 @@ export async function uploadData({ storageType, data, password, forcePassword =
             encryptedData: compressed,
             encryptedDataKey: null,
             dataKey: null,
+            md5Data: await md5(compressed),
             md5Encrypted: null,
         };
     await uploadProgress?.({
@@ -65,6 +63,8 @@ export async function uploadData({ storageType, data, password, forcePassword =
     const createSharing = ({ data, }) => {
         if (dataKey && (password || forcePassword)) {
             password ??= generatePassword();
+            const salt = sodium.crypto_generichash(sodium.crypto_pwhash_SALTBYTES, password + md5Data);
+            const derivedPassword = derivePassword(password, salt);
             let key;
             if (data.type === 'guest' ||
                 (data.type === 'authed' &&
@@ -88,7 +88,7 @@ export async function uploadData({ storageType, data, password, forcePassword =
             // NOTE: Process to create a sharing for a auth client (todo: endpoint)
             return {
                 password,
-                encryptedDataKey: sodium.to_hex(encryptKeyWithPassword(key, password)),
+                encryptedDataKey: sodium.to_hex(encryptSecretBox(key, derivedPassword)),
             };
         }
         return null;
@@ -102,13 +102,14 @@ export async function uploadData({ storageType, data, password, forcePassword =
                 size: BigInt(dataBuffer.byteLength),
                 key: encryptedDataKey ? sodium.to_hex(encryptedDataKey) : undefined,
                 md5Encrypted,
+                md5: md5Data,
                 fromIdentityPubKey: currentIdentity?.identityPubKey,
                 ...filetype,
             }
             : {
                 type: 'unencrypted',
                 content: Buffer.from(encryptedData),
-                md5: await md5(compressed),
+                md5: md5Data,
                 size: BigInt(dataBuffer.byteLength),
                 fromIdentityPubKey: currentIdentity?.identityPubKey,
                 ...filetype,
@@ -123,7 +124,7 @@ export async function uploadData({ storageType, data, password, forcePassword =
         const localData = {
             id: uploadData.id,
             storageType: 'lite',
-            md5: uploadDataArgs.type === 'unencrypted' ? uploadDataArgs.md5 : null,
+            md5: uploadDataArgs.md5,
             size: uploadDataArgs.size,
             sizeEncrypted: uploadDataArgs.type === 'encrypted'
                 ? uploadDataArgs.sizeEncrypted
@@ -145,12 +146,13 @@ export async function uploadData({ storageType, data, password, forcePassword =
                 size: BigInt(dataBuffer.byteLength),
                 key: encryptedDataKey ? sodium.to_hex(encryptedDataKey) : undefined,
                 md5Encrypted,
+                md5: md5Data,
                 fromIdentityPubKey: currentIdentity?.identityPubKey,
                 ...filetype,
             }
             : {
                 type: 'unencrypted',
-                md5: await md5(compressed),
+                md5: md5Data,
                 size: BigInt(dataBuffer.byteLength),
                 fromIdentityPubKey: currentIdentity?.identityPubKey,
                 ...filetype,
@@ -171,7 +173,7 @@ export async function uploadData({ storageType, data, password, forcePassword =
             const localData = {
                 id: uploadData.id,
                 storageType: storageType,
-                md5: uploadDataArgs.type === 'unencrypted' ? uploadDataArgs.md5 : null,
+                md5: uploadDataArgs.md5,
                 size: uploadDataArgs.size,
                 sizeEncrypted: uploadDataArgs.type === 'encrypted'
                     ? uploadDataArgs.sizeEncrypted
@@ -255,7 +257,7 @@ export async function uploadData({ storageType, data, password, forcePassword =
         const localData = {
             id: uploadData.id,
             storageType: storageType,
-            md5: uploadDataArgs.type === 'unencrypted' ? uploadDataArgs.md5 : null,
+            md5: uploadDataArgs.md5,
             size: uploadDataArgs.size,
             sizeEncrypted: uploadDataArgs.type === 'encrypted'
                 ? uploadDataArgs.sizeEncrypted

package/dist/lib/client.js

@@ -24,26 +24,22 @@ export const createTRPCClient = (opts) => innerCreateTRPCClient({
                 : 'https://api.secrecy.tech/trpc',
             maxURLLength: 2083,
             fetch: async (input, init) => {
-                const controller = new AbortController();
-                const id = setTimeout(() => {
-                    controller.abort();
-                }, 20000);
+                const timeout = AbortSignal.timeout(opts.timeoutMs ?? 20_000);
+                const signal = init?.signal
+                    ? AbortSignal.any([init.signal, timeout])
+                    : timeout;
                 const headers = new Headers(init?.headers);
                 headers.set('secrecy-lib-version', SECRECY_LIB_VERSION);
                 if (typeof opts.session === 'string') {
                     headers.set('secrecy-session', opts.session);
                 }
-                const call = fetch(input, {
+                return await fetch(input, {
                     ...init,
                     headers,
-                    signal: controller.signal,
+                    signal,
                     mode: 'cors',
                     credentials: opts.session ? 'include' : 'omit',
                 });
-                void call.finally(() => {
-                    clearTimeout(id);
-                });
-                return await call;
             },
         }),
     ],