@protontech/drive-sdk 0.3.1 → 0.4.0

package/src/internal/sharingPublic/cryptoService.ts

@@ -1,26 +1,34 @@
-import { DriveCrypto, PrivateKey } from '../../crypto';
-import { resultOk, resultError, Result } from '../../interface';
-import { getErrorMessage } from '../errors';
-import { EncryptedShareCrypto, EncryptedNode, DecryptedNode, DecryptedNodeKeys } from './interface';
-
-/**
- * Provides crypto operations for public link data.
- *
- * The public link crypto service is responsible for decrypting and encrypting
- * public link data. It should export high-level actions only, such as "decrypt
- * share key" instead of low-level operations like "decrypt key". Low-level
- * operations should be kept private to the module.
- */
-export class SharingPublicCryptoService {
+import { c } from 'ttag';
+
+import { DriveCrypto, PrivateKey, VERIFICATION_STATUS } from '../../crypto';
+import { getVerificationMessage } from '../errors';
+import {
+    resultOk,
+    resultError,
+    Author,
+    AnonymousUser,
+    ProtonDriveTelemetry,
+    MetricVerificationErrorField,
+    MetricVolumeType,
+    MetricsDecryptionErrorField,
+    Logger,
+    ProtonDriveAccount,
+} from '../../interface';
+import { NodesCryptoService } from '../nodes/cryptoService';
+import { EncryptedShareCrypto } from './interface';
+
+export class SharingPublicCryptoService extends NodesCryptoService {
     constructor(
-        private driveCrypto: DriveCrypto,
+        telemetry: ProtonDriveTelemetry,
+        driveCrypto: DriveCrypto,
+        account: ProtonDriveAccount,
         private password: string,
     ) {
-        this.driveCrypto = driveCrypto;
+        super(telemetry, driveCrypto, account, new SharingPublicCryptoReporter(telemetry));
         this.password = password;
     }
 
-    async decryptShareKey(encryptedShare: EncryptedShareCrypto): Promise<PrivateKey> {
+    async decryptPublicLinkShareKey(encryptedShare: EncryptedShareCrypto): Promise<PrivateKey> {
         const { key: shareKey } = await this.driveCrypto.decryptKeyWithSrpPassword(
             this.password,
             encryptedShare.base64UrlPasswordSalt,
@@ -29,134 +37,62 @@ export class SharingPublicCryptoService {
         );
         return shareKey;
     }
+}
 
-    // TODO: verfiy it has all needed
-    async decryptNode(
-        node: EncryptedNode,
-        parentKey: PrivateKey,
-    ): Promise<{ node: DecryptedNode; keys?: DecryptedNodeKeys }> {
-        const commonNodeMetadata = {
-            ...node,
-            encryptedCrypto: undefined,
-        };
-
-        const { name } = await this.decryptName(node, parentKey);
-
-        let passphrase, key, passphraseSessionKey;
-        try {
-            const keyResult = await this.decryptKey(node, parentKey);
-            passphrase = keyResult.passphrase;
-            key = keyResult.key;
-            passphraseSessionKey = keyResult.passphraseSessionKey;
-        } catch (error: unknown) {
-            return {
-                node: {
-                    ...commonNodeMetadata,
-                    name,
-                    errors: [error],
-                },
-            };
-        }
-
-        const errors = [];
-
-        let hashKey;
-        if ('folder' in node.encryptedCrypto) {
-            try {
-                const hashKeyResult = await this.decryptHashKey(node, key);
-                hashKey = hashKeyResult.hashKey;
-            } catch (error: unknown) {
-                errors.push(error);
-            }
-        }
+class SharingPublicCryptoReporter {
+    private logger: Logger;
+    private telemetry: ProtonDriveTelemetry;
 
-        let contentKeyPacketSessionKey;
-        if ('file' in node.encryptedCrypto) {
-            try {
-                const keySessionKeyResult = await this.driveCrypto.decryptAndVerifySessionKey(
-                    node.encryptedCrypto.file.base64ContentKeyPacket,
-                    '',
-                    key,
-                    [],
-                );
+    constructor(telemetry: ProtonDriveTelemetry) {
+        this.telemetry = telemetry;
+        this.logger = telemetry.getLogger('sharingPublic-crypto');
+    }
 
-                contentKeyPacketSessionKey = keySessionKeyResult.sessionKey;
-            } catch (error: unknown) {
-                errors.push(error);
-            }
+    async handleClaimedAuthor(
+        node: { uid: string; creationTime: Date },
+        field: MetricVerificationErrorField,
+        signatureType: string,
+        verified: VERIFICATION_STATUS,
+        verificationErrors?: Error[],
+        claimedAuthor?: string,
+        notAvailableVerificationKeys = false,
+    ): Promise<Author> {
+        if (verified === VERIFICATION_STATUS.SIGNED_AND_VALID) {
+            return resultOk(claimedAuthor || (null as AnonymousUser));
         }
 
-        return {
-            node: {
-                ...commonNodeMetadata,
-                name,
-                errors: errors.length ? errors : undefined,
-            },
-            keys: {
-                passphrase,
-                key,
-                passphraseSessionKey,
-                contentKeyPacketSessionKey,
-                hashKey,
-            },
-        };
+        return resultError({
+            claimedAuthor,
+            error: !claimedAuthor
+                ? c('Info').t`Author is not provided on public link`
+                : getVerificationMessage(verified, verificationErrors, signatureType, notAvailableVerificationKeys),
+        });
     }
 
-    private async decryptKey(node: EncryptedNode, parentKey: PrivateKey): Promise<DecryptedNodeKeys> {
-        const key = await this.driveCrypto.decryptKey(
-            node.encryptedCrypto.armoredKey,
-            node.encryptedCrypto.armoredNodePassphrase,
-            '',
-            [parentKey],
-            [],
-        );
-
-        return {
-            passphrase: key.passphrase,
-            key: key.key,
-            passphraseSessionKey: key.passphraseSessionKey,
-        };
-    }
+    reportDecryptionError(
+        node: { uid: string; creationTime: Date },
+        field: MetricsDecryptionErrorField,
+        error: unknown,
+    ) {
+        const fromBefore2024 = node.creationTime < new Date('2024-01-01');
 
-    private async decryptName(
-        node: EncryptedNode,
-        parentKey: PrivateKey,
-    ): Promise<{
-        name: Result<string, Error>;
-    }> {
-        try {
-            const { name } = await this.driveCrypto.decryptNodeName(node.encryptedName, parentKey, []);
+        this.logger.error(
+            `Failed to decrypt public link node ${node.uid} (from before 2024: ${fromBefore2024})`,
+            error,
+        );
 
-            return {
-                name: resultOk(name),
-            };
-        } catch (error: unknown) {
-            const errorMessage = getErrorMessage(error);
-            return {
-                name: resultError(new Error(errorMessage)),
-            };
-        }
+        this.telemetry.recordMetric({
+            eventName: 'decryptionError',
+            volumeType: MetricVolumeType.SharedPublic,
+            field,
+            fromBefore2024,
+            error,
+            uid: node.uid,
+        });
     }
 
-    private async decryptHashKey(
-        node: EncryptedNode,
-        nodeKey: PrivateKey,
-    ): Promise<{
-        hashKey: Uint8Array;
-    }> {
-        if (!('folder' in node.encryptedCrypto)) {
-            // This is developer error.
-            throw new Error('Node is not a folder');
-        }
-
-        const { hashKey } = await this.driveCrypto.decryptNodeHashKey(
-            node.encryptedCrypto.folder.armoredHashKey,
-            nodeKey,
-            [],
-        );
-
-        return {
-            hashKey,
-        };
+    reportVerificationError() {
+        // Authors or signatures are not provided on public links.
+        // We do not report any signature verification errors at this moment.
     }
 }

package/src/internal/sharingPublic/index.ts

@@ -1,5 +1,5 @@
 import { DriveCrypto } from '../../crypto';
-import { ProtonDriveCryptoCache, ProtonDriveTelemetry } from '../../interface';
+import { ProtonDriveCryptoCache, ProtonDriveTelemetry, ProtonDriveAccount } from '../../interface';
 import { DriveAPIService } from '../apiService';
 import { SharingPublicAPIService } from './apiService';
 import { SharingPublicCryptoCache } from './cryptoCache';
@@ -22,12 +22,13 @@ export function initSharingPublicModule(
     apiService: DriveAPIService,
     driveCryptoCache: ProtonDriveCryptoCache,
     driveCrypto: DriveCrypto,
+    account: ProtonDriveAccount,
     token: string,
     password: string,
 ) {
     const api = new SharingPublicAPIService(telemetry.getLogger('sharingPublic-api'), apiService);
     const cryptoCache = new SharingPublicCryptoCache(telemetry.getLogger('sharingPublic-crypto'), driveCryptoCache);
-    const cryptoService = new SharingPublicCryptoService(driveCrypto, password);
+    const cryptoService = new SharingPublicCryptoService(telemetry, driveCrypto, account, password);
     const manager = new SharingPublicManager(
         telemetry.getLogger('sharingPublic-nodes'),
         api,

package/src/internal/sharingPublic/interface.ts

@@ -1,59 +1,14 @@
-import { PrivateKey, SessionKey } from "../../crypto";
-import { NodeType, Result, InvalidNameError } from "../../interface";
+// TODO: use them directly, or avoid them completely
+export type {
+    EncryptedNode,
+    EncryptedNodeFolderCrypto,
+    EncryptedNodeFileCrypto,
+    DecryptedNode,
+    DecryptedNodeKeys,
+} from '../nodes/interface';
 
 export interface EncryptedShareCrypto {
     base64UrlPasswordSalt: string;
     armoredKey: string;
     armoredPassphrase: string;
 }
-
-// TODO: reuse node entity, or keep custom?
-interface BaseNode {
-    // Internal metadata
-    hash?: string; // root node doesn't have any hash
-    encryptedName: string;
-
-    // Basic node metadata
-    uid: string;
-    parentUid?: string;
-    type: NodeType;
-    mediaType?: string;
-    totalStorageSize?: number;
-}
-
-export interface EncryptedNode extends BaseNode {
-    encryptedCrypto: EncryptedNodeFolderCrypto | EncryptedNodeFileCrypto;
-}
-
-export interface EncryptedNodeCrypto {
-    signatureEmail?: string;
-    armoredKey: string;
-    armoredNodePassphrase: string;
-    armoredNodePassphraseSignature?: string;
-}
-
-export interface EncryptedNodeFileCrypto extends EncryptedNodeCrypto {
-    file: {
-        base64ContentKeyPacket: string;
-    };
-}
-
-export interface EncryptedNodeFolderCrypto extends EncryptedNodeCrypto {
-    folder: {
-        armoredExtendedAttributes?: string;
-        armoredHashKey: string;
-    };
-}
-
-export interface DecryptedNode extends BaseNode {
-    name: Result<string, Error | InvalidNameError>;
-    errors?: unknown[];
-}
-
-export interface DecryptedNodeKeys {
-    passphrase: string;
-    key: PrivateKey;
-    passphraseSessionKey: SessionKey;
-    contentKeyPacketSessionKey?: SessionKey;
-    hashKey?: Uint8Array;
-}

package/src/internal/sharingPublic/manager.ts

@@ -1,5 +1,6 @@
 import { PrivateKey } from '../../crypto';
 import { Logger } from '../../interface';
+import { parseNode } from '../nodes/nodesAccess';
 import { SharingPublicAPIService } from './apiService';
 import { SharingPublicCryptoCache } from './cryptoCache';
 import { SharingPublicCryptoService } from './cryptoService';
@@ -27,35 +28,35 @@ export class SharingPublicManager {
         return this.decryptNode(encryptedNode);
     }
 
-    async *iterateChildren(parentUid: string): AsyncGenerator<DecryptedNode> {
+    async *iterateFolderChildren(parentUid: string, signal?: AbortSignal): AsyncGenerator<DecryptedNode> {
         // TODO: optimise this - decrypt in parallel
-        for await (const node of this.api.iterateChildren(parentUid)) {
+        for await (const node of this.api.iterateFolderChildren(parentUid, signal)) {
             const decryptedNode = await this.decryptNode(node);
             yield decryptedNode;
         }
     }
 
     private async decryptShare(encryptedShare: EncryptedShareCrypto): Promise<void> {
-        const shareKey = await this.cryptoService.decryptShareKey(encryptedShare);
+        const shareKey = await this.cryptoService.decryptPublicLinkShareKey(encryptedShare);
         await this.cryptoCache.setShareKey(shareKey);
     }
 
     private async decryptNode(encryptedNode: EncryptedNode): Promise<DecryptedNode> {
         const parentKey = await this.getParentKey(encryptedNode);
 
-        const { node: decryptedNode, keys } = await this.cryptoService.decryptNode(encryptedNode, parentKey);
+        const { node: unparsedNode, keys } = await this.cryptoService.decryptNode(encryptedNode, parentKey);
+        const node = await parseNode(this.logger, unparsedNode);
 
         // TODO: cache of metadata?
-
         if (keys) {
             try {
-                await this.cryptoCache.setNodeKeys(decryptedNode.uid, keys);
+                await this.cryptoCache.setNodeKeys(node.uid, keys);
             } catch (error: unknown) {
-                this.logger.error(`Failed to cache node keys ${decryptedNode.uid}`, error);
+                this.logger.error(`Failed to cache node keys ${node.uid}`, error);
             }
         }
 
-        return decryptedNode;
+        return node;
     }
 
     private async getParentKey(node: Pick<DecryptedNode, 'parentUid'>): Promise<PrivateKey> {

package/src/internal/upload/streamUploader.test.ts

@@ -189,8 +189,10 @@ describe('StreamUploader', () => {
 
         const verifyOnProgress = async (uploadedBytes: number[]) => {
             expect(onProgress).toHaveBeenCalledTimes(uploadedBytes.length);
+            let fileProgress = 0;
             for (let i = 0; i < uploadedBytes.length; i++) {
-                expect(onProgress).toHaveBeenNthCalledWith(i + 1, uploadedBytes[i]);
+                fileProgress += uploadedBytes[i];
+                expect(onProgress).toHaveBeenNthCalledWith(i + 1, fileProgress);
             }
         };
 

package/src/internal/upload/streamUploader.ts

@@ -122,7 +122,7 @@ export class StreamUploader {
             this.logger.info(`Starting upload`);
             await this.encryptAndUploadBlocks(stream, thumbnails, (uploadedBytes) => {
                 fileProgress += uploadedBytes;
-                onProgress?.(uploadedBytes);
+                onProgress?.(fileProgress);
             });
 
             this.logger.debug(`All blocks uploaded, committing`);

package/src/protonDriveClient.ts

@@ -27,6 +27,7 @@ import {
     ThumbnailType,
     ThumbnailResult,
     SDKEvent,
+    NodeType,
 } from './interface';
 import {
     getUid,
@@ -208,6 +209,7 @@ export class ProtonDriveClient {
                 return new ProtonDrivePublicLinkClient({
                     httpClient,
                     cryptoCache,
+                    account,
                     openPGPCryptoModule,
                     srpModule,
                     config,
@@ -251,7 +253,7 @@ export class ProtonDriveClient {
     }
 
     /**
-     * Subscribes to sharing updates.
+     * Subscribes to the remote general data updates.
      *
      * Only one instance of the SDK should subscribe to updates.
      */
@@ -284,7 +286,7 @@ export class ProtonDriveClient {
      */
     async getMyFilesRootFolder(): Promise<MaybeNode> {
         this.logger.info('Getting my files root folder');
-        return convertInternalNodePromise(this.nodes.access.getMyFilesRootFolder());
+        return convertInternalNodePromise(this.nodes.access.getVolumeRootFolder());
     }
 
     /**
@@ -296,9 +298,14 @@ export class ProtonDriveClient {
      * @param signal - Signal to abort the operation.
      * @returns An async generator of the children of the given parent node.
      */
-    async *iterateFolderChildren(parentNodeUid: NodeOrUid, signal?: AbortSignal): AsyncGenerator<MaybeNode> {
+    async *iterateFolderChildren(
+        parentNodeUid: NodeOrUid,
+        filterOptions?: { type?: NodeType },
+        signal?: AbortSignal,
+    ): AsyncGenerator<MaybeNode> {
         this.logger.info(`Iterating children of ${getUid(parentNodeUid)}`);
-        yield* convertInternalNodeIterator(this.nodes.access.iterateFolderChildren(getUid(parentNodeUid), signal));
+        const iterator = this.nodes.access.iterateFolderChildren(getUid(parentNodeUid), filterOptions, signal);
+        yield* convertInternalNodeIterator(iterator);
     }
 
     /**
@@ -383,6 +390,29 @@ export class ProtonDriveClient {
         yield* this.nodes.management.moveNodes(getUids(nodeUids), getUid(newParentNodeUid), signal);
     }
 
+    /**
+     * Copy the nodes to a new parent node.
+     *
+     * The operation is performed node by node and the results are yielded
+     * as they are available. Order of the results is not guaranteed.
+     *
+     * If one of the nodes fails to copy, the operation continues with the
+     * rest of the nodes. Use `NodeResult` to check the status of the action.
+     *
+     * @param nodeUids - List of node entities or their UIDs.
+     * @param newParentNodeUid - Node entity or its UID string.
+     * @param signal - Signal to abort the operation.
+     * @returns An async generator of the results of the copy operation
+     */
+    async *copyNodes(
+        nodeUids: NodeOrUid[],
+        newParentNodeUid: NodeOrUid,
+        signal?: AbortSignal,
+    ): AsyncGenerator<NodeResult> {
+        this.logger.info(`Copying ${nodeUids.length} nodes to ${getUid(newParentNodeUid)}`);
+        yield* this.nodes.management.copyNodes(getUids(nodeUids), getUid(newParentNodeUid), signal);
+    }
+
     /**
      * Trash the nodes.
      *