@protontech/drive-sdk 0.3.1 → 0.3.2

package/dist/protonDrivePublicLinkClient.js

@@ -26,7 +26,7 @@ class ProtonDrivePublicLinkClient {
     sdkEvents;
     sharingPublic;
     experimental;
-    constructor({ httpClient, cryptoCache, openPGPCryptoModule, srpModule, config, telemetry, token, password, }) {
+    constructor({ httpClient, cryptoCache, account, openPGPCryptoModule, srpModule, config, telemetry, token, password, }) {
         if (!telemetry) {
             telemetry = new telemetry_1.Telemetry();
         }
@@ -35,7 +35,7 @@ class ProtonDrivePublicLinkClient {
         this.sdkEvents = new sdkEvents_1.SDKEvents(telemetry);
         const apiService = new apiService_1.DriveAPIService(telemetry, this.sdkEvents, httpClient, fullConfig.baseUrl, fullConfig.language);
         const driveCrypto = new crypto_1.DriveCrypto(openPGPCryptoModule, srpModule);
-        this.sharingPublic = (0, sharingPublic_1.initSharingPublicModule)(telemetry, apiService, cryptoCache, driveCrypto, token, password);
+        this.sharingPublic = (0, sharingPublic_1.initSharingPublicModule)(telemetry, apiService, cryptoCache, driveCrypto, account, token, password);
         this.experimental = {
             getNodeUrl: async (nodeUid) => {
                 this.logger.debug(`Getting node URL for ${(0, transformers_1.getUid)(nodeUid)}`);
@@ -52,19 +52,21 @@ class ProtonDrivePublicLinkClient {
             },
         };
     }
-    // TODO: comment
-    // TODO: add public node interface
+    /**
+     * @returns The root folder to the public link.
+     */
     async getRootNode() {
         this.logger.info(`Getting root node`);
-        // TODO: conversion to public node
-        return this.sharingPublic.getRootNode();
+        return (0, transformers_1.convertInternalNodePromise)(this.sharingPublic.getRootNode());
     }
-    // TODO: comment
-    // TODO: add public node interface
-    async *iterateChildren(parentUid) {
+    /**
+     * Iterates the children of the given parent node.
+     *
+     * See `ProtonDriveClient.iterateFolderChildren` for more information.
+     */
+    async *iterateFolderChildren(parentUid, signal) {
         this.logger.info(`Iterating children of ${(0, transformers_1.getUid)(parentUid)}`);
-        // TODO: conversion to public node
-        yield* this.sharingPublic.iterateChildren((0, transformers_1.getUid)(parentUid));
+        yield* (0, transformers_1.convertInternalNodeIterator)(this.sharingPublic.iterateFolderChildren((0, transformers_1.getUid)(parentUid), signal));
     }
 }
 exports.ProtonDrivePublicLinkClient = ProtonDrivePublicLinkClient;

package/dist/protonDrivePublicLinkClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"protonDrivePublicLinkClient.js","sourceRoot":"","sources":["../src/protonDrivePublicLinkClient.ts"],"names":[],"mappings":";;;AAAA,qCAAqC;AACrC,qCAA6E;AAS7E,2CAAwC;AACxC,iDAAwC;AACxC,sDAAwD;AACxD,oDAAiD;AACjD,4DAAmE;AAEnE;;;;;;;;;;;;GAYG;AACH,MAAa,2BAA2B;IAC5B,MAAM,CAAS;IACf,SAAS,CAAY;IACrB,aAAa,CAA6C;IAE3D,YAAY,CAejB;IAEF,YAAY,EACR,UAAU,EACV,WAAW,EACX,mBAAmB,EACnB,SAAS,EACT,MAAM,EACN,SAAS,EACT,KAAK,EACL,QAAQ,GAUX;QACG,IAAI,CAAC,SAAS,EAAE,CAAC;YACb,SAAS,GAAG,IAAI,qBAAS,EAAE,CAAC;QAChC,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;QAE/C,MAAM,UAAU,GAAG,IAAA,kBAAS,EAAC,MAAM,CAAC,CAAC;QACrC,IAAI,CAAC,SAAS,GAAG,IAAI,qBAAS,CAAC,SAAS,CAAC,CAAC;QAE1C,MAAM,UAAU,GAAG,IAAI,4BAAe,CAClC,SAAS,EACT,IAAI,CAAC,SAAS,EACd,UAAU,EACV,UAAU,CAAC,OAAO,EAClB,UAAU,CAAC,QAAQ,CACtB,CAAC;QACF,MAAM,WAAW,GAAG,IAAI,oBAAW,CAAC,mBAAmB,EAAE,SAAS,CAAC,CAAC;QACpE,IAAI,CAAC,aAAa,GAAG,IAAA,uCAAuB,EAAC,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;QAE/G,IAAI,CAAC,YAAY,GAAG;YAChB,UAAU,EAAE,KAAK,EAAE,OAAkB,EAAE,EAAE;gBACrC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,wBAAwB,IAAA,qBAAM,EAAC,OAAO,CAAC,EAAE,CAAC,CAAC;gBAC7D,sCAAsC;gBACtC,OAAO,EAAE,CAAC;YACd,CAAC;YACD,UAAU,EAAE,KAAK,EAAE,OAAkB,EAAE,EAAE;gBACrC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,yBAAyB,IAAA,qBAAM,EAAC,OAAO,CAAC,EAAE,CAAC,CAAC;gBAC9D,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,IAAA,qBAAM,EAAC,OAAO,CAAC,CAAC,CAAC;gBACnE,IAAI,CAAC,IAAI,CAAC,0BAA0B,EAAE,CAAC;oBACnC,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;gBAC3E,CAAC;gBACD,OAAO,IAAI,CAAC,0BAA0B,CAAC;YAC3C,CAAC;SACJ,CAAC;IACN,CAAC;IAED,gBAAgB;IAChB,kCAAkC;IAClC,KAAK,CAAC,WAAW;QACb,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACtC,kCAAkC;QAClC,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;IAC5C,CAAC;IAED,gBAAgB;IAChB,kCAAkC;IAClC,KAAK,CAAC,CAAC,eAAe,CAAC,SAAoB;QACvC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,IAAA,qBAAM,EAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QAC/D,kCAAkC;QAClC,KAAM,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,IAAA,qBAAM,EAAC,SAAS,CAAC,CAAC,CAAC;IAClE,CAAC;CACJ;AA3FD,kEA2FC"}
+{"version":3,"file":"protonDrivePublicLinkClient.js","sourceRoot":"","sources":["../src/protonDrivePublicLinkClient.ts"],"names":[],"mappings":";;;AAAA,qCAAqC;AACrC,qCAA6E;AAW7E,2CAAwC;AACxC,iDAAiG;AACjG,sDAAwD;AACxD,oDAAiD;AACjD,4DAAmE;AAEnE;;;;;;;;;;;;GAYG;AACH,MAAa,2BAA2B;IAC5B,MAAM,CAAS;IACf,SAAS,CAAY;IACrB,aAAa,CAA6C;IAE3D,YAAY,CAejB;IAEF,YAAY,EACR,UAAU,EACV,WAAW,EACX,OAAO,EACP,mBAAmB,EACnB,SAAS,EACT,MAAM,EACN,SAAS,EACT,KAAK,EACL,QAAQ,GAWX;QACG,IAAI,CAAC,SAAS,EAAE,CAAC;YACb,SAAS,GAAG,IAAI,qBAAS,EAAE,CAAC;QAChC,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;QAE/C,MAAM,UAAU,GAAG,IAAA,kBAAS,EAAC,MAAM,CAAC,CAAC;QACrC,IAAI,CAAC,SAAS,GAAG,IAAI,qBAAS,CAAC,SAAS,CAAC,CAAC;QAE1C,MAAM,UAAU,GAAG,IAAI,4BAAe,CAClC,SAAS,EACT,IAAI,CAAC,SAAS,EACd,UAAU,EACV,UAAU,CAAC,OAAO,EAClB,UAAU,CAAC,QAAQ,CACtB,CAAC;QACF,MAAM,WAAW,GAAG,IAAI,oBAAW,CAAC,mBAAmB,EAAE,SAAS,CAAC,CAAC;QACpE,IAAI,CAAC,aAAa,GAAG,IAAA,uCAAuB,EACxC,SAAS,EACT,UAAU,EACV,WAAW,EACX,WAAW,EACX,OAAO,EACP,KAAK,EACL,QAAQ,CACX,CAAC;QAEF,IAAI,CAAC,YAAY,GAAG;YAChB,UAAU,EAAE,KAAK,EAAE,OAAkB,EAAE,EAAE;gBACrC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,wBAAwB,IAAA,qBAAM,EAAC,OAAO,CAAC,EAAE,CAAC,CAAC;gBAC7D,sCAAsC;gBACtC,OAAO,EAAE,CAAC;YACd,CAAC;YACD,UAAU,EAAE,KAAK,EAAE,OAAkB,EAAE,EAAE;gBACrC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,yBAAyB,IAAA,qBAAM,EAAC,OAAO,CAAC,EAAE,CAAC,CAAC;gBAC9D,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,IAAA,qBAAM,EAAC,OAAO,CAAC,CAAC,CAAC;gBACnE,IAAI,CAAC,IAAI,CAAC,0BAA0B,EAAE,CAAC;oBACnC,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;gBAC3E,CAAC;gBACD,OAAO,IAAI,CAAC,0BAA0B,CAAC;YAC3C,CAAC;SACJ,CAAC;IACN,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,WAAW;QACb,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACtC,OAAO,IAAA,yCAA0B,EAAC,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC,CAAC;IACxE,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,CAAC,qBAAqB,CAAC,SAAoB,EAAE,MAAoB;QACnE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,IAAA,qBAAM,EAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QAC/D,KAAM,CAAC,CAAC,IAAA,0CAA2B,EAAC,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC,IAAA,qBAAM,EAAC,SAAS,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;IAC7G,CAAC;CACJ;AAvGD,kEAuGC"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@protontech/drive-sdk",
-    "version": "0.3.1",
+    "version": "0.3.2",
     "description": "Proton Drive SDK",
     "license": "GPL-3.0",
     "main": "dist/index.js",

package/src/crypto/driveCrypto.ts

@@ -170,7 +170,7 @@ export class DriveCrypto {
     async decryptKey(
         armoredKey: string,
         armoredPassphrase: string,
-        armoredPassphraseSignature: string,
+        armoredPassphraseSignature: string | undefined,
         decryptionKeys: PrivateKey[],
         verificationKeys: PublicKey[],
     ): Promise<{

package/src/crypto/interface.ts

@@ -240,7 +240,7 @@ export interface OpenPGPCrypto {
 
     decryptArmoredAndVerifyDetached: (
         armoredData: string,
-        armoredSignature: string,
+        armoredSignature: string | undefined,
         sessionKey: SessionKey,
         verificationKeys: PublicKey | PublicKey[],
     ) => Promise<{

package/src/crypto/openPGPCrypto.ts

@@ -1,3 +1,4 @@
+import { c } from 'ttag';
 import { OpenPGPCrypto, PrivateKey, PublicKey, SessionKey, VERIFICATION_STATUS } from './interface';
 import { uint8ArrayToBase64String } from './utils';
 
@@ -393,7 +394,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
 
     async decryptArmoredAndVerifyDetached(
         armoredData: string,
-        armoredSignature: string,
+        armoredSignature: string | undefined,
         sessionKey: SessionKey,
         verificationKeys: PublicKey | PublicKey[],
     ) {
@@ -410,7 +411,9 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
             // Proper typing is too complex, it will be removed to support only newer pmcrypto.
             verified: verified || verificationStatus!,
-            verificationErrors,
+            verificationErrors: !armoredSignature
+                ? [new Error(c('Error').t`Signature is missing`)]
+                : verificationErrors,
         };
     }
 

package/src/internal/download/cryptoService.ts

@@ -49,7 +49,7 @@ export class DownloadCryptoService {
             );
         } catch (error: unknown) {
             const message = getErrorMessage(error);
-            throw new DecryptionError(c('Error').t`Failed to decrypt block: ${message}`);
+            throw new DecryptionError(c('Error').t`Failed to decrypt block: ${message}`, { cause: error });
         }
 
         return decryptedBlock;
@@ -66,7 +66,7 @@ export class DownloadCryptoService {
             decryptedBlock = result.decryptedThumbnail;
         } catch (error: unknown) {
             const message = getErrorMessage(error);
-            throw new DecryptionError(c('Error').t`Failed to decrypt thumbnail: ${message}`);
+            throw new DecryptionError(c('Error').t`Failed to decrypt thumbnail: ${message}`, { cause: error });
         }
 
         return decryptedBlock;

package/src/internal/download/fileDownloader.test.ts

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

package/src/internal/download/fileDownloader.ts

@@ -134,7 +134,7 @@ export class FileDownloader {
             const blockData = await this.downloadBlockData(blockMetadata, true, cryptoKeys);
             return blockData.slice(blockOffset);
         } catch (error: unknown) {
-            return error instanceof Error ? error : new Error(`Unknown error: ${error}`);
+            return error instanceof Error ? error : new Error(`Unknown error: ${error}`, { cause: error });
         }
     }
 
@@ -193,7 +193,7 @@ export class FileDownloader {
                     cryptoKeys,
                     (downloadedBytes) => {
                         fileProgress += downloadedBytes;
-                        onProgress?.(downloadedBytes);
+                        onProgress?.(fileProgress);
                     },
                 );
                 this.ongoingDownloads.set(blockMetadata.index, { downloadPromise });

package/src/internal/nodes/cache.ts

@@ -53,7 +53,9 @@ export class NodesCache {
             return deserialiseNode(nodeData);
         } catch (error: unknown) {
             await this.removeCorruptedNode({ nodeUid }, error);
-            throw new Error(`Failed to deserialise node: ${error instanceof Error ? error.message : error}`);
+            throw new Error(`Failed to deserialise node: ${error instanceof Error ? error.message : error}`, {
+                cause: error,
+            });
         }
     }
 

package/src/internal/nodes/cryptoReporter.ts

@@ -0,0 +1,145 @@
+import { VERIFICATION_STATUS } from '../../crypto';
+import {
+    resultOk,
+    resultError,
+    Author,
+    AnonymousUser,
+    ProtonDriveTelemetry,
+    Logger,
+    MetricsDecryptionErrorField,
+    MetricVerificationErrorField,
+} from '../../interface';
+import { getVerificationMessage } from '../errors';
+import { splitNodeUid } from '../uids';
+import {
+    EncryptedNode,
+    SharesService,
+} from './interface';
+
+export class NodesCryptoReporter {
+    private logger: Logger;
+
+    private reportedDecryptionErrors = new Set<string>();
+    private reportedVerificationErrors = new Set<string>();
+
+    constructor(
+        private telemetry: ProtonDriveTelemetry,
+        private shareService: SharesService,
+    ) {
+        this.telemetry = telemetry;
+        this.logger = telemetry.getLogger('nodes-crypto');
+        this.shareService = shareService;
+    }
+
+    async handleClaimedAuthor(
+        node: { uid: string; creationTime: Date },
+        field: MetricVerificationErrorField,
+        signatureType: string,
+        verified: VERIFICATION_STATUS,
+        verificationErrors?: Error[],
+        claimedAuthor?: string,
+        notAvailableVerificationKeys = false,
+    ): Promise<Author> {
+        const author = handleClaimedAuthor(
+            signatureType,
+            verified,
+            verificationErrors,
+            claimedAuthor,
+            notAvailableVerificationKeys,
+        );
+        if (!author.ok) {
+            void this.reportVerificationError(node, field, verificationErrors, claimedAuthor);
+        }
+        return author;
+    }
+
+    async reportVerificationError(
+        node: { uid: string; creationTime: Date },
+        field: MetricVerificationErrorField,
+        verificationErrors?: Error[],
+        claimedAuthor?: string,
+    ) {
+        if (this.reportedVerificationErrors.has(node.uid)) {
+            return;
+        }
+        this.reportedVerificationErrors.add(node.uid);
+
+        const fromBefore2024 = node.creationTime < new Date('2024-01-01');
+
+        let addressMatchingDefaultShare, volumeType;
+        try {
+            const { volumeId } = splitNodeUid(node.uid);
+            const { email } = await this.shareService.getMyFilesShareMemberEmailKey();
+            addressMatchingDefaultShare = claimedAuthor ? claimedAuthor === email : undefined;
+            volumeType = await this.shareService.getVolumeMetricContext(volumeId);
+        } catch (error: unknown) {
+            this.logger.error('Failed to check if claimed author matches default share', error);
+        }
+
+        this.logger.warn(
+            `Failed to verify ${field} for node ${node.uid} (from before 2024: ${fromBefore2024}, matching address: ${addressMatchingDefaultShare})`,
+        );
+
+        this.telemetry.recordMetric({
+            eventName: 'verificationError',
+            volumeType,
+            field,
+            addressMatchingDefaultShare,
+            fromBefore2024,
+            error: verificationErrors?.map((e) => e.message).join(', '),
+            uid: node.uid,
+        });
+    }
+
+    async reportDecryptionError(node: EncryptedNode, field: MetricsDecryptionErrorField, error: unknown) {
+        if (this.reportedDecryptionErrors.has(node.uid)) {
+            return;
+        }
+
+        const fromBefore2024 = node.creationTime < new Date('2024-01-01');
+
+        let volumeType;
+        try {
+            const { volumeId } = splitNodeUid(node.uid);
+            volumeType = await this.shareService.getVolumeMetricContext(volumeId);
+        } catch (error: unknown) {
+            this.logger.error('Failed to get metric context', error);
+        }
+
+        this.logger.error(`Failed to decrypt node ${node.uid} (from before 2024: ${fromBefore2024})`, error);
+
+        this.telemetry.recordMetric({
+            eventName: 'decryptionError',
+            volumeType,
+            field,
+            fromBefore2024,
+            error,
+            uid: node.uid,
+        });
+        this.reportedDecryptionErrors.add(node.uid);
+    }
+}
+
+/**
+ * @param signatureType - Must be translated before calling this function.
+ */
+function handleClaimedAuthor(
+    signatureType: string,
+    verified: VERIFICATION_STATUS,
+    verificationErrors?: Error[],
+    claimedAuthor?: string,
+    notAvailableVerificationKeys = false,
+): Author {
+    if (!claimedAuthor && notAvailableVerificationKeys) {
+        return resultOk(null as AnonymousUser);
+    }
+
+    if (verified === VERIFICATION_STATUS.SIGNED_AND_VALID) {
+        return resultOk(claimedAuthor || (null as AnonymousUser));
+    }
+
+    return resultError({
+        claimedAuthor,
+        error: getVerificationMessage(verified, verificationErrors, signatureType, notAvailableVerificationKeys),
+    });
+}

package/src/internal/nodes/cryptoService.test.ts

@@ -3,6 +3,7 @@ import { MemberRole, ProtonDriveAccount, ProtonDriveTelemetry, RevisionState } f
 import { getMockTelemetry } from '../../tests/telemetry';
 import { DecryptedNode, DecryptedNodeKeys, DecryptedUnparsedNode, EncryptedNode, SharesService } from './interface';
 import { NodesCryptoService } from './cryptoService';
+import { NodesCryptoReporter } from './cryptoReporter';
 
 describe('nodesCryptoService', () => {
     let telemetry: ProtonDriveTelemetry;
@@ -74,7 +75,8 @@ describe('nodesCryptoService', () => {
             getVolumeMetricContext: jest.fn().mockResolvedValue('own_volume'),
         };
 
-        cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, sharesService);
+        const nodesCryptoReporter = new NodesCryptoReporter(telemetry, sharesService);
+        cryptoService = new NodesCryptoService(telemetry, driveCrypto, account, nodesCryptoReporter);
     });
 
     const parentKey = 'parentKey' as unknown as PrivateKey;

package/src/internal/nodes/cryptoService.ts

@@ -7,27 +7,49 @@ import {
     Result,
     Author,
     AnonymousUser,
-    ProtonDriveAccount,
     ProtonDriveTelemetry,
     Logger,
     MetricsDecryptionErrorField,
     MetricVerificationErrorField,
     Membership,
+    ProtonDriveAccount,
 } from '../../interface';
 import { ValidationError } from '../../errors';
-import { getErrorMessage, getVerificationMessage } from '../errors';
-import { splitNodeUid } from '../uids';
+import { getErrorMessage } from '../errors';
 import {
     EncryptedNode,
     EncryptedNodeFolderCrypto,
     DecryptedUnparsedNode,
     DecryptedNode,
     DecryptedNodeKeys,
-    SharesService,
     EncryptedRevision,
     DecryptedUnparsedRevision,
 } from './interface';
 
+export interface NodesCryptoReporter {
+    handleClaimedAuthor(
+        node: NodesCryptoReporterNode,
+        field: MetricVerificationErrorField,
+        signatureType: string,
+        verified: VERIFICATION_STATUS,
+        verificationErrors?: Error[],
+        claimedAuthor?: string,
+        notAvailableVerificationKeys?: boolean,
+    ): Promise<Author>;
+    reportDecryptionError(node: NodesCryptoReporterNode, field: MetricsDecryptionErrorField, error: unknown): void;
+    reportVerificationError(
+        node: NodesCryptoReporterNode,
+        field: MetricVerificationErrorField,
+        verificationErrors?: Error[],
+        claimedAuthor?: string,
+    ): void;
+}
+
+type NodesCryptoReporterNode = {
+    uid: string;
+    creationTime: Date;
+};
+
 /**
  * Provides crypto operations for nodes metadata.
  *
@@ -41,20 +63,16 @@ import {
 export class NodesCryptoService {
     private logger: Logger;
 
-    private reportedDecryptionErrors = new Set<string>();
-    private reportedVerificationErrors = new Set<string>();
-
     constructor(
-        private telemetry: ProtonDriveTelemetry,
-        private driveCrypto: DriveCrypto,
+        telemetry: ProtonDriveTelemetry,
+        protected driveCrypto: DriveCrypto,
         private account: ProtonDriveAccount,
-        private shareService: SharesService,
+        private reporter: NodesCryptoReporter,
     ) {
-        this.telemetry = telemetry;
         this.logger = telemetry.getLogger('nodes-crypto');
         this.driveCrypto = driveCrypto;
         this.account = account;
-        this.shareService = shareService;
+        this.reporter = reporter;
     }
 
     async decryptNode(
@@ -107,7 +125,7 @@ export class NodesCryptoService {
             passphraseSessionKey = keyResult.passphraseSessionKey;
             keyAuthor = keyResult.author;
         } catch (error: unknown) {
-            void this.reportDecryptionError(node, 'nodeKey', error);
+            void this.reporter.reportDecryptionError(node, 'nodeKey', error);
             const message = getErrorMessage(error);
             const errorMessage = c('Error').t`Failed to decrypt node key: ${message}`;
             const { name, author: nameAuthor } = await namePromise;
@@ -159,7 +177,7 @@ export class NodesCryptoService {
                 hashKey = hashKeyResult.hashKey;
                 hashKeyAuthor = hashKeyResult.author;
             } catch (error: unknown) {
-                void this.reportDecryptionError(node, 'nodeHashKey', error);
+                void this.reporter.reportDecryptionError(node, 'nodeHashKey', error);
                 errors.push(error);
             }
 
@@ -170,7 +188,7 @@ export class NodesCryptoService {
                 };
                 folderExtendedAttributesAuthor = extendedAttributesResult.author;
             } catch (error: unknown) {
-                void this.reportDecryptionError(node, 'nodeExtendedAttributes', error);
+                void this.reporter.reportDecryptionError(node, 'nodeExtendedAttributes', error);
                 errors.push(error);
             }
         }
@@ -194,7 +212,7 @@ export class NodesCryptoService {
             try {
                 activeRevision = resultOk(await activeRevisionPromise);
             } catch (error: unknown) {
-                void this.reportDecryptionError(node, 'nodeExtendedAttributes', error);
+                void this.reporter.reportDecryptionError(node, 'nodeExtendedAttributes', error);
                 const message = getErrorMessage(error);
                 const errorMessage = c('Error').t`Failed to decrypt active revision: ${message}`;
                 activeRevision = resultError(new Error(errorMessage));
@@ -205,7 +223,7 @@ export class NodesCryptoService {
                 contentKeyPacketSessionKey = keySessionKeyResult.sessionKey;
                 contentKeyPacketAuthor =
                     keySessionKeyResult.verified !== undefined &&
-                    (await this.handleClaimedAuthor(
+                    (await this.reporter.handleClaimedAuthor(
                         node,
                         'nodeContentKey',
                         c('Property').t`content key`,
@@ -214,7 +232,7 @@ export class NodesCryptoService {
                         node.encryptedCrypto.signatureEmail,
                     ));
             } catch (error: unknown) {
-                void this.reportDecryptionError(node, 'nodeContentKey', error);
+                void this.reporter.reportDecryptionError(node, 'nodeContentKey', error);
                 const message = getErrorMessage(error);
                 const errorMessage = c('Error').t`Failed to decrypt content key: ${message}`;
                 contentKeyPacketAuthor = resultError({
@@ -295,7 +313,7 @@ export class NodesCryptoService {
             passphrase: key.passphrase,
             key: key.key,
             passphraseSessionKey: key.passphraseSessionKey,
-            author: await this.handleClaimedAuthor(
+            author: await this.reporter.handleClaimedAuthor(
                 node,
                 'nodeKey',
                 c('Property').t`key`,
@@ -326,7 +344,7 @@ export class NodesCryptoService {
 
             return {
                 name: resultOk(name),
-                author: await this.handleClaimedAuthor(
+                author: await this.reporter.handleClaimedAuthor(
                     node,
                     'nodeName',
                     c('Property').t`name`,
@@ -337,7 +355,7 @@ export class NodesCryptoService {
                 ),
             };
         } catch (error: unknown) {
-            void this.reportDecryptionError(node, 'nodeName', error);
+            void this.reporter.reportDecryptionError(node, 'nodeName', error);
             const errorMessage = getErrorMessage(error);
             return {
                 name: resultError(new Error(errorMessage)),
@@ -378,7 +396,7 @@ export class NodesCryptoService {
                     inviterEmailKeys || [],
                 );
 
-                sharedBy = await this.handleClaimedAuthor(
+                sharedBy = await this.reporter.handleClaimedAuthor(
                     node,
                     'membershipInviter',
                     c('Property').t`membership`,
@@ -387,7 +405,7 @@ export class NodesCryptoService {
                     node.encryptedCrypto.membership.inviterEmail,
                 );
             } catch (error: unknown) {
-                void this.reportVerificationError(node, 'membershipInviter');
+                void this.reporter.reportVerificationError(node, 'membershipInviter');
                 this.logger.error('Failed to verify invitation', error);
                 sharedBy = resultError({
                     claimedAuthor: node.encryptedCrypto.membership.inviterEmail,
@@ -428,7 +446,7 @@ export class NodesCryptoService {
 
         return {
             hashKey,
-            author: await this.handleClaimedAuthor(
+            author: await this.reporter.handleClaimedAuthor(
                 node,
                 'nodeHashKey',
                 c('Property').t`hash key`,
@@ -491,7 +509,7 @@ export class NodesCryptoService {
 
         return {
             extendedAttributes,
-            author: await this.handleClaimedAuthor(
+            author: await this.reporter.handleClaimedAuthor(
                 node,
                 'nodeExtendedAttributes',
                 c('Property').t`attributes`,
@@ -509,6 +527,7 @@ export class NodesCryptoService {
         extendedAttributes?: string,
     ): Promise<{
         encryptedCrypto: EncryptedNodeFolderCrypto & {
+            armoredNodePassphraseSignature: string;
             // signatureEmail and nameSignatureEmail are not optional.
             signatureEmail: string;
             nameSignatureEmail: string;
@@ -626,118 +645,6 @@ export class NodesCryptoService {
             nameSignatureEmail: email,
         };
     }
-
-    private async handleClaimedAuthor(
-        node: { uid: string; creationTime: Date },
-        field: MetricVerificationErrorField,
-        signatureType: string,
-        verified: VERIFICATION_STATUS,
-        verificationErrors?: Error[],
-        claimedAuthor?: string,
-        notAvailableVerificationKeys = false,
-    ): Promise<Author> {
-        const author = handleClaimedAuthor(
-            signatureType,
-            verified,
-            verificationErrors,
-            claimedAuthor,
-            notAvailableVerificationKeys,
-        );
-        if (!author.ok) {
-            void this.reportVerificationError(node, field, verificationErrors, claimedAuthor);
-        }
-        return author;
-    }
-
-    private async reportVerificationError(
-        node: { uid: string; creationTime: Date },
-        field: MetricVerificationErrorField,
-        verificationErrors?: Error[],
-        claimedAuthor?: string,
-    ) {
-        if (this.reportedVerificationErrors.has(node.uid)) {
-            return;
-        }
-        this.reportedVerificationErrors.add(node.uid);
-
-        const fromBefore2024 = node.creationTime < new Date('2024-01-01');
-
-        let addressMatchingDefaultShare, volumeType;
-        try {
-            const { volumeId } = splitNodeUid(node.uid);
-            const { email } = await this.shareService.getMyFilesShareMemberEmailKey();
-            addressMatchingDefaultShare = claimedAuthor ? claimedAuthor === email : undefined;
-            volumeType = await this.shareService.getVolumeMetricContext(volumeId);
-        } catch (error: unknown) {
-            this.logger.error('Failed to check if claimed author matches default share', error);
-        }
-
-        this.logger.warn(
-            `Failed to verify ${field} for node ${node.uid} (from before 2024: ${fromBefore2024}, matching address: ${addressMatchingDefaultShare})`,
-        );
-
-        this.telemetry.recordMetric({
-            eventName: 'verificationError',
-            volumeType,
-            field,
-            addressMatchingDefaultShare,
-            fromBefore2024,
-            error: verificationErrors?.map((e) => e.message).join(', '),
-            uid: node.uid,
-        });
-    }
-
-    private async reportDecryptionError(node: EncryptedNode, field: MetricsDecryptionErrorField, error: unknown) {
-        if (this.reportedDecryptionErrors.has(node.uid)) {
-            return;
-        }
-
-        const fromBefore2024 = node.creationTime < new Date('2024-01-01');
-
-        let volumeType;
-        try {
-            const { volumeId } = splitNodeUid(node.uid);
-            volumeType = await this.shareService.getVolumeMetricContext(volumeId);
-        } catch (error: unknown) {
-            this.logger.error('Failed to get metric context', error);
-        }
-
-        this.logger.error(`Failed to decrypt node ${node.uid} (from before 2024: ${fromBefore2024})`, error);
-
-        this.telemetry.recordMetric({
-            eventName: 'decryptionError',
-            volumeType,
-            field,
-            fromBefore2024,
-            error,
-            uid: node.uid,
-        });
-        this.reportedDecryptionErrors.add(node.uid);
-    }
-}
-
-/**
- * @param signatureType - Must be translated before calling this function.
- */
-function handleClaimedAuthor(
-    signatureType: string,
-    verified: VERIFICATION_STATUS,
-    verificationErrors?: Error[],
-    claimedAuthor?: string,
-    notAvailableVerificationKeys = false,
-): Author {
-    if (!claimedAuthor && notAvailableVerificationKeys) {
-        return resultOk(null as AnonymousUser);
-    }
-
-    if (verified === VERIFICATION_STATUS.SIGNED_AND_VALID) {
-        return resultOk(claimedAuthor || (null as AnonymousUser));
-    }
-
-    return resultError({
-        claimedAuthor: claimedAuthor,
-        error: getVerificationMessage(verified, verificationErrors, signatureType, notAvailableVerificationKeys),
-    });
 }
 
 function getClaimedAuthor(