@brftech/filex-core 0.6.0 → 0.7.0

package/dist/index.d.ts

@@ -45,6 +45,13 @@ declare type __VLS_Props_11 = {
     active?: boolean;
 };
 
+declare type __VLS_Props_12 = {
+    open: boolean;
+    locale: LocaleCode;
+    /** True while the parent is creating the folder + uploading the marker. */
+    busy?: boolean;
+};
+
 declare type __VLS_Props_2 = {
     open: boolean;
     locale: LocaleCode;
@@ -63,6 +70,7 @@ declare type __VLS_Props_2 = {
     pdfSaveUrl?: string | null;
     /** Standalone full-screen viewer route — `?path=…&storage=…&type=…`. */
     viewerBaseUrl?: string | null;
+    newTabEnabled?: boolean;
     /** Drop the dialog chrome (backdrop tint, header bar, footer actions)
      *  so the viewer fills the full viewport. Used by the standalone
      *  /files/edit route where the browser tab IS the container — a
@@ -249,16 +257,122 @@ declare interface ContextAction {
     divider?: boolean;
 }
 
+/**
+ * Tiny per-explorer key ring: encrypted-folder root (wire path) → KEK.
+ * Lives ONLY in memory — "Kilitle" drops the entry, a reload drops all.
+ */
+export declare function createKeyRing(): {
+    get(root: string): CryptoKey | undefined;
+    set(root: string, kek: CryptoKey): void;
+    /** Drop one folder's key ("Kilitle"). */
+    lock(root: string): void;
+    has(root: string): boolean;
+    clear(): void;
+};
+
+/** Create a fresh folder marker for `password` (also returns the derived KEK). */
+export declare function createMarker(password: string, iterations?: number): Promise<{
+    marker: E2eMarker;
+    kek: CryptoKey;
+}>;
+
+/**
+ * Decrypt a 'filexe2e' blob with the folder KEK. Throws E2eDecryptError on
+ * a wrong key / tampered data, and a plain Error when the header is not an
+ * e2e file at all.
+ */
+export declare function decryptFile(kek: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
+
 export declare const DEFAULT_THEME_ID = "default";
 
 declare type Density = 'comfortable' | 'compact';
 
+/**
+ * Derive the folder KEK from a password. Returns a NON-extractable
+ * AES-256-GCM CryptoKey — it can encrypt/decrypt but never be exported,
+ * so even a same-origin script can't read the raw key material back.
+ */
+export declare function deriveKek(password: string, salt: Uint8Array, iterations: number): Promise<CryptoKey>;
+
+export declare const E2E_DEFAULT_ITERATIONS = 600000;
+
+export declare const E2E_MAGIC = "filexe2e";
+
+/**
+ * e2ecrypto — client-side crypto for E2E-encrypted folders (wiring:e2).
+ *
+ * WebCrypto ONLY — zero dependencies. Design doc: docs/E2E-ENCRYPTION.md.
+ *
+ * Scheme (v1):
+ *   folder password ─PBKDF2-SHA256(600k iter, per-folder 16B salt)─▶ KEK (AES-256-GCM)
+ *   per-file random 32B DEK (AES-256-GCM) encrypts the content one-shot;
+ *   the DEK is wrapped with the KEK and stored in the file's own header.
+ *
+ * File layout ('filexe2e' magic, fixed 97-byte header):
+ *   [0..8)   magic  "filexe2e"
+ *   [8]      version 0x01
+ *   [9..21)  wrapIV  (12B)  — GCM IV of the DEK wrap
+ *   [21..69) wrappedDEK (48B = 32B DEK + 16B GCM tag)
+ *   [69..81) dataIV  (12B)  — GCM IV of the content
+ *   [81..97) reserved (zeros; v2 chunking/metadata)
+ *   [97..)   ciphertext (content + 16B GCM tag)
+ *
+ * Folder marker `.filex-e2e.json` at the encrypted-folder root:
+ *   { v:1, salt:<b64 16B>, iter:600000, verify:<b64 12B IV || GCM('filex-e2e-verify-v1')> }
+ *
+ * The KEK NEVER leaves memory — no storage of any kind. Password loss is
+ * data loss by design (no recovery path exists anywhere).
+ */
+export declare const E2E_MARKER_NAME = ".filex-e2e.json";
+
+/** MVP single-shot in-memory ceiling — larger uploads are refused with a warning. */
+export declare const E2E_MAX_FILE_BYTES: number;
+
+export declare const E2E_MIN_PASSWORD_LEN = 8;
+
+export declare const E2E_VERSION = 1;
+
+/** Thrown on wrong password / corrupted ciphertext (GCM tag mismatch). */
+export declare class E2eDecryptError extends Error {
+    constructor(msg?: string);
+}
+
+export declare type E2eKeyRing = ReturnType<typeof createKeyRing>;
+
+export declare interface E2eMarker {
+    v: number;
+    salt: string;
+    iter: number;
+    verify: string;
+}
+
 /** Current combo for an action ('' = unbound). */
 export declare function effectiveCombo(id: string): string;
 
 /** English UI strings. */
 export declare const en: Record<string, string>;
 
+export declare const EncryptedFolderModal: DefineComponent<__VLS_Props_12, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
+close: () => any;
+submit: (payload: {
+name: string;
+password: string;
+}) => any;
+}, string, PublicProps, Readonly<__VLS_Props_12> & Readonly<{
+onClose?: (() => any) | undefined;
+onSubmit?: ((payload: {
+name: string;
+password: string;
+}) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+/**
+ * Encrypt `content` under the folder KEK: mints a fresh DEK, encrypts the
+ * content one-shot, wraps the DEK with the KEK and prepends the fixed
+ * 'filexe2e' header. Throws when content exceeds E2E_MAX_FILE_BYTES.
+ */
+export declare function encryptFile(kek: CryptoKey, content: ArrayBuffer): Promise<ArrayBuffer>;
+
 /**
  * Resolved endpoint map. `useFileApi` derives this once on construction
  * — components never need to think about config/apiBase precedence.
@@ -843,6 +957,7 @@ export declare interface FileNode {
      *  projectFileNodes emits it when a storage has RBAC on). '' / undefined =
      *  ACL not enforced. Used to gate edit/manage affordances client-side. */
     perm?: 'none' | 'viewer' | 'editor' | 'owner';
+    e2e?: boolean;
     /** Generic — any additional fields the backend wants to inline. */
     [k: string]: unknown;
 }
@@ -910,6 +1025,9 @@ declare interface Grant {
     inherited?: boolean;
 }
 
+/** True when the buffer starts with the 'filexe2e' magic. */
+export declare function hasMagic(buf: ArrayBuffer | Uint8Array): boolean;
+
 declare interface InviteResponse {
     mode: 'granted' | 'user_created' | 'shared';
     user_id?: number;
@@ -935,6 +1053,8 @@ export declare interface ManagerResponse {
     /** RBAC effective level for the current user on this directory ('' when ACL
      *  is not enforced on the storage). Gates the folder-level write actions. */
     perm?: 'none' | 'viewer' | 'editor' | 'owner';
+    e2e?: boolean;
+    e2e_root?: string;
     files: FileNode[];
 }
 
@@ -1053,6 +1173,9 @@ export declare type OperationsStore = ReturnType<typeof useOperations>;
 
 export declare type OperationStatus = 'running' | 'done' | 'error' | 'aborted';
 
+/** Parse marker JSON text; returns null when the shape is not a v1 marker. */
+export declare function parseMarker(text: string): E2eMarker | null;
+
 export declare interface PendingOp {
     id: number;
     op_type: 'copy' | 'move' | 'delete';
@@ -1823,6 +1946,13 @@ export declare function useUploadChunked(config: ExplorerConfig, api: FileApi):
     uploadFile: (opts: UploadOptions) => Promise<UploadFinalizeResponse>;
 };
 
+/**
+ * Check `password` against a folder marker. Resolves to the derived KEK on
+ * success, or `null` on a wrong password (GCM tag mismatch on the verify
+ * blob). Never talks to any server.
+ */
+export declare function verifyPassword(marker: E2eMarker, password: string): Promise<CryptoKey | null>;
+
 export declare type ViewMode = 'list' | 'grid' | 'gallery';
 
 export { }