@protontech/drive-sdk 0.3.1 → 0.3.2

package/src/internal/sharingPublic/apiService.ts

@@ -1,5 +1,5 @@
 import { DriveAPIService, drivePaths, nodeTypeNumberToNodeType } from '../apiService';
-import { Logger } from '../../interface';
+import { Logger, MemberRole } from '../../interface';
 import { makeNodeUid, splitNodeUid } from '../uids';
 import { EncryptedShareCrypto, EncryptedNode } from './interface';
 
@@ -42,13 +42,14 @@ export class SharingPublicAPIService {
         };
     }
 
-    async *iterateChildren(parentUid: string): AsyncGenerator<EncryptedNode> {
+    async *iterateFolderChildren(parentUid: string, signal?: AbortSignal): AsyncGenerator<EncryptedNode> {
         const { volumeId: token, nodeId } = splitNodeUid(parentUid);
 
         let page = 0;
         while (true) {
             const response = await this.apiService.get<GetTokenFolderChildrenResponse>(
                 `drive/urls/${token}/folders/${nodeId}/children?Page=${page}&PageSize=${PAGE_SIZE}`,
+                signal,
             );
 
             for (const link of response.Links) {
@@ -72,6 +73,10 @@ function tokenToEncryptedNode(logger: Logger, token: GetTokenInfoResponse['Token
         uid: makeNodeUid(token.Token, token.LinkID),
         parentUid: undefined,
         type: nodeTypeNumberToNodeType(logger, token.LinkType),
+        creationTime: new Date(), // TODO
+
+        isShared: false,
+        directRole: MemberRole.Viewer, // TODO
     };
 
     const baseCryptoNodeMetadata = {
@@ -124,7 +129,11 @@ function linkToEncryptedNode(
         uid: makeNodeUid(token, link.LinkID),
         parentUid: link.ParentLinkID ? makeNodeUid(token, link.ParentLinkID) : undefined,
         type: nodeTypeNumberToNodeType(logger, link.Type),
+        creationTime: new Date(), // TODO
         totalStorageSize: link.TotalSize,
+
+        isShared: false,
+        directRole: MemberRole.Viewer, // TODO
     };
 
     const baseCryptoNodeMetadata = {

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

@@ -208,6 +208,7 @@ export class ProtonDriveClient {
                 return new ProtonDrivePublicLinkClient({
                     httpClient,
                     cryptoCache,
+                    account,
                     openPGPCryptoModule,
                     srpModule,
                     config,

package/src/protonDrivePublicLinkClient.ts

@@ -7,9 +7,11 @@ import {
     Logger,
     ProtonDriveCryptoCache,
     NodeOrUid,
+    ProtonDriveAccount,
+    MaybeNode,
 } from './interface';
 import { Telemetry } from './telemetry';
-import { getUid } from './transformers';
+import { getUid, convertInternalNodePromise, convertInternalNodeIterator } from './transformers';
 import { DriveAPIService } from './internal/apiService';
 import { SDKEvents } from './internal/sdkEvents';
 import { initSharingPublicModule } from './internal/sharingPublic';
@@ -52,6 +54,7 @@ export class ProtonDrivePublicLinkClient {
     constructor({
         httpClient,
         cryptoCache,
+        account,
         openPGPCryptoModule,
         srpModule,
         config,
@@ -61,6 +64,7 @@ export class ProtonDrivePublicLinkClient {
     }: {
         httpClient: ProtonDriveHTTPClient;
         cryptoCache: ProtonDriveCryptoCache;
+        account: ProtonDriveAccount;
         openPGPCryptoModule: OpenPGPCrypto;
         srpModule: SRPModule;
         config?: ProtonDriveConfig;
@@ -84,7 +88,15 @@ export class ProtonDrivePublicLinkClient {
             fullConfig.language,
         );
         const driveCrypto = new DriveCrypto(openPGPCryptoModule, srpModule);
-        this.sharingPublic = initSharingPublicModule(telemetry, apiService, cryptoCache, driveCrypto, token, password);
+        this.sharingPublic = initSharingPublicModule(
+            telemetry,
+            apiService,
+            cryptoCache,
+            driveCrypto,
+            account,
+            token,
+            password,
+        );
 
         this.experimental = {
             getNodeUrl: async (nodeUid: NodeOrUid) => {
@@ -103,19 +115,21 @@ export class ProtonDrivePublicLinkClient {
         };
     }
 
-    // TODO: comment
-    // TODO: add public node interface
-    async getRootNode() {
+    /**
+     * @returns The root folder to the public link.
+     */
+    async getRootNode(): Promise<MaybeNode> {
         this.logger.info(`Getting root node`);
-        // TODO: conversion to public node
-        return this.sharingPublic.getRootNode();
+        return convertInternalNodePromise(this.sharingPublic.getRootNode());
     }
 
-    // TODO: comment
-    // TODO: add public node interface
-    async *iterateChildren(parentUid: NodeOrUid) {
+    /**
+     * Iterates the children of the given parent node.
+     *
+     * See `ProtonDriveClient.iterateFolderChildren` for more information.
+     */
+    async *iterateFolderChildren(parentUid: NodeOrUid, signal?: AbortSignal): AsyncGenerator<MaybeNode> {
         this.logger.info(`Iterating children of ${getUid(parentUid)}`);
-        // TODO: conversion to public node
-        yield * this.sharingPublic.iterateChildren(getUid(parentUid));
+        yield * convertInternalNodeIterator(this.sharingPublic.iterateFolderChildren(getUid(parentUid), signal));
     }
 }