@protontech/drive-sdk 0.3.0 → 0.3.2

package/dist/internal/sharingPublic/cryptoService.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharingPublicCryptoService = void 0;
+const ttag_1 = require("ttag");
+const crypto_1 = require("../../crypto");
+const errors_1 = require("../errors");
+const interface_1 = require("../../interface");
+const cryptoService_1 = require("../nodes/cryptoService");
+class SharingPublicCryptoService extends cryptoService_1.NodesCryptoService {
+    password;
+    constructor(telemetry, driveCrypto, account, password) {
+        super(telemetry, driveCrypto, account, new SharingPublicCryptoReporter(telemetry));
+        this.password = password;
+        this.password = password;
+    }
+    async decryptPublicLinkShareKey(encryptedShare) {
+        const { key: shareKey } = await this.driveCrypto.decryptKeyWithSrpPassword(this.password, encryptedShare.base64UrlPasswordSalt, encryptedShare.armoredKey, encryptedShare.armoredPassphrase);
+        return shareKey;
+    }
+}
+exports.SharingPublicCryptoService = SharingPublicCryptoService;
+class SharingPublicCryptoReporter {
+    logger;
+    telemetry;
+    constructor(telemetry) {
+        this.telemetry = telemetry;
+        this.logger = telemetry.getLogger('sharingPublic-crypto');
+    }
+    async handleClaimedAuthor(node, field, signatureType, verified, verificationErrors, claimedAuthor, notAvailableVerificationKeys = false) {
+        if (verified === crypto_1.VERIFICATION_STATUS.SIGNED_AND_VALID) {
+            return (0, interface_1.resultOk)(claimedAuthor || null);
+        }
+        return (0, interface_1.resultError)({
+            claimedAuthor,
+            error: !claimedAuthor
+                ? (0, ttag_1.c)('Info').t `Author is not provided on public link`
+                : (0, errors_1.getVerificationMessage)(verified, verificationErrors, signatureType, notAvailableVerificationKeys),
+        });
+    }
+    reportDecryptionError(node, field, error) {
+        const fromBefore2024 = node.creationTime < new Date('2024-01-01');
+        this.logger.error(`Failed to decrypt public link node ${node.uid} (from before 2024: ${fromBefore2024})`, error);
+        this.telemetry.recordMetric({
+            eventName: 'decryptionError',
+            volumeType: interface_1.MetricVolumeType.SharedPublic,
+            field,
+            fromBefore2024,
+            error,
+            uid: node.uid,
+        });
+    }
+    reportVerificationError() {
+        // Authors or signatures are not provided on public links.
+        // We do not report any signature verification errors at this moment.
+    }
+}
+//# sourceMappingURL=cryptoService.js.map

package/dist/internal/sharingPublic/cryptoService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cryptoService.js","sourceRoot":"","sources":["../../../src/internal/sharingPublic/cryptoService.ts"],"names":[],"mappings":";;;AAAA,+BAAyB;AAEzB,yCAA4E;AAC5E,sCAAmD;AACnD,+CAWyB;AACzB,0DAA4D;AAG5D,MAAa,0BAA2B,SAAQ,kCAAkB;IAKlD;IAJZ,YACI,SAA+B,EAC/B,WAAwB,EACxB,OAA2B,EACnB,QAAgB;QAExB,KAAK,CAAC,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,2BAA2B,CAAC,SAAS,CAAC,CAAC,CAAC;QAF3E,aAAQ,GAAR,QAAQ,CAAQ;QAGxB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,yBAAyB,CAAC,cAAoC;QAChE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,yBAAyB,CACtE,IAAI,CAAC,QAAQ,EACb,cAAc,CAAC,qBAAqB,EACpC,cAAc,CAAC,UAAU,EACzB,cAAc,CAAC,iBAAiB,CACnC,CAAC;QACF,OAAO,QAAQ,CAAC;IACpB,CAAC;CACJ;AApBD,gEAoBC;AAED,MAAM,2BAA2B;IACrB,MAAM,CAAS;IACf,SAAS,CAAuB;IAExC,YAAY,SAA+B;QACvC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,SAAS,CAAC,sBAAsB,CAAC,CAAC;IAC9D,CAAC;IAED,KAAK,CAAC,mBAAmB,CACrB,IAAyC,EACzC,KAAmC,EACnC,aAAqB,EACrB,QAA6B,EAC7B,kBAA4B,EAC5B,aAAsB,EACtB,4BAA4B,GAAG,KAAK;QAEpC,IAAI,QAAQ,KAAK,4BAAmB,CAAC,gBAAgB,EAAE,CAAC;YACpD,OAAO,IAAA,oBAAQ,EAAC,aAAa,IAAK,IAAsB,CAAC,CAAC;QAC9D,CAAC;QAED,OAAO,IAAA,uBAAW,EAAC;YACf,aAAa;YACb,KAAK,EAAE,CAAC,aAAa;gBACjB,CAAC,CAAC,IAAA,QAAC,EAAC,MAAM,CAAC,CAAC,CAAC,CAAA,uCAAuC;gBACpD,CAAC,CAAC,IAAA,+BAAsB,EAAC,QAAQ,EAAE,kBAAkB,EAAE,aAAa,EAAE,4BAA4B,CAAC;SAC1G,CAAC,CAAC;IACP,CAAC;IAED,qBAAqB,CACjB,IAAyC,EACzC,KAAkC,EAClC,KAAc;QAEd,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC;QAElE,IAAI,CAAC,MAAM,CAAC,KAAK,CACb,sCAAsC,IAAI,CAAC,GAAG,uBAAuB,cAAc,GAAG,EACtF,KAAK,CACR,CAAC;QAEF,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;YACxB,SAAS,EAAE,iBAAiB;YAC5B,UAAU,EAAE,4BAAgB,CAAC,YAAY;YACzC,KAAK;YACL,cAAc;YACd,KAAK;YACL,GAAG,EAAE,IAAI,CAAC,GAAG;SAChB,CAAC,CAAC;IACP,CAAC;IAED,uBAAuB;QACnB,0DAA0D;QAC1D,qEAAqE;IACzE,CAAC;CACJ"}

package/dist/internal/sharingPublic/index.d.ts

@@ -0,0 +1,15 @@
+import { DriveCrypto } from '../../crypto';
+import { ProtonDriveCryptoCache, ProtonDriveTelemetry, ProtonDriveAccount } from '../../interface';
+import { DriveAPIService } from '../apiService';
+import { SharingPublicManager } from './manager';
+export { SharingPublicSessionManager } from './session/manager';
+/**
+ * Provides facade for the whole sharing public module.
+ *
+ * The sharing public module is responsible for handling public link data, including
+ * API communication, encryption, decryption, and caching.
+ *
+ * This facade provides internal interface that other modules can use to
+ * interact with the public links.
+ */
+export declare function initSharingPublicModule(telemetry: ProtonDriveTelemetry, apiService: DriveAPIService, driveCryptoCache: ProtonDriveCryptoCache, driveCrypto: DriveCrypto, account: ProtonDriveAccount, token: string, password: string): SharingPublicManager;

package/dist/internal/sharingPublic/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharingPublicSessionManager = void 0;
+exports.initSharingPublicModule = initSharingPublicModule;
+const apiService_1 = require("./apiService");
+const cryptoCache_1 = require("./cryptoCache");
+const cryptoService_1 = require("./cryptoService");
+const manager_1 = require("./manager");
+var manager_2 = require("./session/manager");
+Object.defineProperty(exports, "SharingPublicSessionManager", { enumerable: true, get: function () { return manager_2.SharingPublicSessionManager; } });
+/**
+ * Provides facade for the whole sharing public module.
+ *
+ * The sharing public module is responsible for handling public link data, including
+ * API communication, encryption, decryption, and caching.
+ *
+ * This facade provides internal interface that other modules can use to
+ * interact with the public links.
+ */
+function initSharingPublicModule(telemetry, apiService, driveCryptoCache, driveCrypto, account, token, password) {
+    const api = new apiService_1.SharingPublicAPIService(telemetry.getLogger('sharingPublic-api'), apiService);
+    const cryptoCache = new cryptoCache_1.SharingPublicCryptoCache(telemetry.getLogger('sharingPublic-crypto'), driveCryptoCache);
+    const cryptoService = new cryptoService_1.SharingPublicCryptoService(telemetry, driveCrypto, account, password);
+    const manager = new manager_1.SharingPublicManager(telemetry.getLogger('sharingPublic-nodes'), api, cryptoCache, cryptoService, token);
+    return manager;
+}
+//# sourceMappingURL=index.js.map

package/dist/internal/sharingPublic/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/internal/sharingPublic/index.ts"],"names":[],"mappings":";;;AAmBA,0DAqBC;AArCD,6CAAuD;AACvD,+CAAyD;AACzD,mDAA6D;AAC7D,uCAAiD;AAEjD,6CAAgE;AAAvD,sHAAA,2BAA2B,OAAA;AAEpC;;;;;;;;GAQG;AACH,SAAgB,uBAAuB,CACnC,SAA+B,EAC/B,UAA2B,EAC3B,gBAAwC,EACxC,WAAwB,EACxB,OAA2B,EAC3B,KAAa,EACb,QAAgB;IAEhB,MAAM,GAAG,GAAG,IAAI,oCAAuB,CAAC,SAAS,CAAC,SAAS,CAAC,mBAAmB,CAAC,EAAE,UAAU,CAAC,CAAC;IAC9F,MAAM,WAAW,GAAG,IAAI,sCAAwB,CAAC,SAAS,CAAC,SAAS,CAAC,sBAAsB,CAAC,EAAE,gBAAgB,CAAC,CAAC;IAChH,MAAM,aAAa,GAAG,IAAI,0CAA0B,CAAC,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAChG,MAAM,OAAO,GAAG,IAAI,8BAAoB,CACpC,SAAS,CAAC,SAAS,CAAC,qBAAqB,CAAC,EAC1C,GAAG,EACH,WAAW,EACX,aAAa,EACb,KAAK,CACR,CAAC;IAEF,OAAO,OAAO,CAAC;AACnB,CAAC"}

package/dist/internal/sharingPublic/interface.d.ts

@@ -0,0 +1,6 @@
+export type { EncryptedNode, EncryptedNodeFolderCrypto, EncryptedNodeFileCrypto, DecryptedNode, DecryptedNodeKeys, } from '../nodes/interface';
+export interface EncryptedShareCrypto {
+    base64UrlPasswordSalt: string;
+    armoredKey: string;
+    armoredPassphrase: string;
+}

package/dist/internal/sharingPublic/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/dist/internal/sharingPublic/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.js","sourceRoot":"","sources":["../../../src/internal/sharingPublic/interface.ts"],"names":[],"mappings":""}

package/dist/internal/sharingPublic/manager.d.ts

@@ -0,0 +1,19 @@
+import { Logger } from '../../interface';
+import { SharingPublicAPIService } from './apiService';
+import { SharingPublicCryptoCache } from './cryptoCache';
+import { SharingPublicCryptoService } from './cryptoService';
+import { DecryptedNode, DecryptedNodeKeys } from './interface';
+export declare class SharingPublicManager {
+    private logger;
+    private api;
+    private cryptoCache;
+    private cryptoService;
+    private token;
+    constructor(logger: Logger, api: SharingPublicAPIService, cryptoCache: SharingPublicCryptoCache, cryptoService: SharingPublicCryptoService, token: string);
+    getRootNode(): Promise<DecryptedNode>;
+    iterateFolderChildren(parentUid: string, signal?: AbortSignal): AsyncGenerator<DecryptedNode>;
+    private decryptShare;
+    private decryptNode;
+    private getParentKey;
+    getNodeKeys(nodeUid: string): Promise<DecryptedNodeKeys>;
+}

package/dist/internal/sharingPublic/manager.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharingPublicManager = void 0;
+const nodesAccess_1 = require("../nodes/nodesAccess");
+// TODO: comment
+class SharingPublicManager {
+    logger;
+    api;
+    cryptoCache;
+    cryptoService;
+    token;
+    constructor(logger, api, cryptoCache, cryptoService, token) {
+        this.logger = logger;
+        this.api = api;
+        this.cryptoCache = cryptoCache;
+        this.cryptoService = cryptoService;
+        this.token = token;
+        this.logger = logger;
+        this.api = api;
+        this.cryptoCache = cryptoCache;
+        this.cryptoService = cryptoService;
+        this.token = token;
+    }
+    async getRootNode() {
+        const { encryptedNode, encryptedShare } = await this.api.getPublicLinkRoot(this.token);
+        await this.decryptShare(encryptedShare);
+        return this.decryptNode(encryptedNode);
+    }
+    async *iterateFolderChildren(parentUid, signal) {
+        // TODO: optimise this - decrypt in parallel
+        for await (const node of this.api.iterateFolderChildren(parentUid, signal)) {
+            const decryptedNode = await this.decryptNode(node);
+            yield decryptedNode;
+        }
+    }
+    async decryptShare(encryptedShare) {
+        const shareKey = await this.cryptoService.decryptPublicLinkShareKey(encryptedShare);
+        await this.cryptoCache.setShareKey(shareKey);
+    }
+    async decryptNode(encryptedNode) {
+        const parentKey = await this.getParentKey(encryptedNode);
+        const { node: unparsedNode, keys } = await this.cryptoService.decryptNode(encryptedNode, parentKey);
+        const node = await (0, nodesAccess_1.parseNode)(this.logger, unparsedNode);
+        // TODO: cache of metadata?
+        if (keys) {
+            try {
+                await this.cryptoCache.setNodeKeys(node.uid, keys);
+            }
+            catch (error) {
+                this.logger.error(`Failed to cache node keys ${node.uid}`, error);
+            }
+        }
+        return node;
+    }
+    async getParentKey(node) {
+        if (node.parentUid) {
+            // TODO: try-catch
+            const keys = await this.getNodeKeys(node.parentUid);
+            return keys.key;
+        }
+        try {
+            return await this.cryptoCache.getShareKey();
+        }
+        catch {
+            await this.getRootNode();
+            return this.cryptoCache.getShareKey();
+        }
+    }
+    async getNodeKeys(nodeUid) {
+        try {
+            const keys = await this.cryptoCache.getNodeKeys(nodeUid);
+            return keys;
+        }
+        catch {
+            // TODO: handle this
+            throw new Error('Node key not found in cache');
+        }
+    }
+}
+exports.SharingPublicManager = SharingPublicManager;
+//# sourceMappingURL=manager.js.map

package/dist/internal/sharingPublic/manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.js","sourceRoot":"","sources":["../../../src/internal/sharingPublic/manager.ts"],"names":[],"mappings":"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"}

package/dist/internal/sharingPublic/session/apiService.d.ts

@@ -0,0 +1,28 @@
+import { DriveAPIService } from '../../apiService';
+import { PublicLinkInfo, PublicLinkSrpAuth } from './interface';
+/**
+ * Provides API communication for managing public link session (not data).
+ *
+ * The service is responsible for transforming local objects to API payloads
+ * and vice versa. It should not contain any business logic.
+ */
+export declare class SharingPublicSessionAPIService {
+    private apiService;
+    constructor(apiService: DriveAPIService);
+    /**
+     * Start a SRP handshake for public link session.
+     */
+    initPublicLinkSession(token: string): Promise<PublicLinkInfo>;
+    /**
+     * Authenticate a public link session.
+     *
+     * It returns the server proof that must be validated, and the session uid
+     * with an optional access token. The access token is only returned if
+     * the session is newly created.
+     */
+    authPublicLinkSession(token: string, srp: PublicLinkSrpAuth): Promise<{
+        serverProof: string;
+        sessionUid: string;
+        sessionAccessToken?: string;
+    }>;
+}

package/dist/internal/sharingPublic/session/apiService.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharingPublicSessionAPIService = void 0;
+/**
+ * Provides API communication for managing public link session (not data).
+ *
+ * The service is responsible for transforming local objects to API payloads
+ * and vice versa. It should not contain any business logic.
+ */
+class SharingPublicSessionAPIService {
+    apiService;
+    constructor(apiService) {
+        this.apiService = apiService;
+        this.apiService = apiService;
+    }
+    /**
+     * Start a SRP handshake for public link session.
+     */
+    async initPublicLinkSession(token) {
+        const response = await this.apiService.get(`drive/urls/${token}/info`);
+        return {
+            srp: {
+                version: response.Version,
+                modulus: response.Modulus,
+                serverEphemeral: response.ServerEphemeral,
+                salt: response.UrlPasswordSalt,
+                srpSession: response.SRPSession,
+            },
+            isCustomPasswordProtected: (response.Flags & 1) === 1,
+            isLegacy: response.Flags === 0 || response.Flags === 1,
+            vendorType: response.VendorType,
+        };
+    }
+    /**
+     * Authenticate a public link session.
+     *
+     * It returns the server proof that must be validated, and the session uid
+     * with an optional access token. The access token is only returned if
+     * the session is newly created.
+     */
+    async authPublicLinkSession(token, srp) {
+        const response = await this.apiService.post(`drive/urls/${token}/auth`, {
+            ClientProof: srp.clientProof,
+            ClientEphemeral: srp.clientEphemeral,
+            SRPSession: srp.srpSession,
+        });
+        return {
+            serverProof: response.ServerProof,
+            sessionUid: response.UID,
+            sessionAccessToken: response.AccessToken,
+        };
+    }
+}
+exports.SharingPublicSessionAPIService = SharingPublicSessionAPIService;
+//# sourceMappingURL=apiService.js.map

package/dist/internal/sharingPublic/session/apiService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiService.js","sourceRoot":"","sources":["../../../../src/internal/sharingPublic/session/apiService.ts"],"names":[],"mappings":";;;AAaA;;;;;GAKG;AACH,MAAa,8BAA8B;IACnB;IAApB,YAAoB,UAA2B;QAA3B,eAAU,GAAV,UAAU,CAAiB;QAC3C,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,qBAAqB,CAAC,KAAa;QACrC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAA4B,cAAc,KAAK,OAAO,CAAC,CAAC;QAClG,OAAO;YACH,GAAG,EAAE;gBACD,OAAO,EAAE,QAAQ,CAAC,OAAO;gBACzB,OAAO,EAAE,QAAQ,CAAC,OAAO;gBACzB,eAAe,EAAE,QAAQ,CAAC,eAAe;gBACzC,IAAI,EAAE,QAAQ,CAAC,eAAe;gBAC9B,UAAU,EAAE,QAAQ,CAAC,UAAU;aAClC;YACD,yBAAyB,EAAE,CAAC,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC;YACrD,QAAQ,EAAE,QAAQ,CAAC,KAAK,KAAK,CAAC,IAAI,QAAQ,CAAC,KAAK,KAAK,CAAC;YACtD,UAAU,EAAE,QAAQ,CAAC,UAAU;SAClC,CAAC;IACN,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,qBAAqB,CACvB,KAAa,EACb,GAAsB;QAMtB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CACvC,cAAc,KAAK,OAAO,EAC1B;YACI,WAAW,EAAE,GAAG,CAAC,WAAW;YAC5B,eAAe,EAAE,GAAG,CAAC,eAAe;YACpC,UAAU,EAAE,GAAG,CAAC,UAAU;SAC7B,CACJ,CAAC;QAEF,OAAO;YACH,WAAW,EAAE,QAAQ,CAAC,WAAW;YACjC,UAAU,EAAE,QAAQ,CAAC,GAAG;YACxB,kBAAkB,EAAE,QAAQ,CAAC,WAAW;SAC3C,CAAC;IACN,CAAC;CACJ;AAtDD,wEAsDC"}

package/dist/internal/sharingPublic/session/httpClient.d.ts

@@ -0,0 +1,16 @@
+import { ProtonDriveHTTPClient, ProtonDriveHTTPClientBlobRequest, ProtonDriveHTTPClientJsonRequest } from '../../../interface';
+import { SharingPublicLinkSession } from './session';
+/**
+ * HTTP client to get access to public link of given session.
+ *
+ * It is responsible for adding the session headers to the request if the session
+ * is authenticated, and re-authenticating the session if the session is expired.
+ */
+export declare class SharingPublicSessionHttpClient implements ProtonDriveHTTPClient {
+    private httpClient;
+    private session;
+    constructor(httpClient: ProtonDriveHTTPClient, session: SharingPublicLinkSession);
+    fetchJson(options: ProtonDriveHTTPClientJsonRequest): Promise<Response>;
+    fetchBlob(options: ProtonDriveHTTPClientBlobRequest): Promise<Response>;
+    private getOptionsWithSessionHeaders;
+}

package/dist/internal/sharingPublic/session/httpClient.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharingPublicSessionHttpClient = void 0;
+/**
+ * HTTP client to get access to public link of given session.
+ *
+ * It is responsible for adding the session headers to the request if the session
+ * is authenticated, and re-authenticating the session if the session is expired.
+ */
+class SharingPublicSessionHttpClient {
+    httpClient;
+    session;
+    constructor(httpClient, session) {
+        this.httpClient = httpClient;
+        this.session = session;
+        this.httpClient = httpClient;
+        this.session = session;
+    }
+    async fetchJson(options) {
+        const response = await this.httpClient.fetchJson(this.getOptionsWithSessionHeaders(options));
+        if (response.status === 401 /* HTTPErrorCode.UNAUTHORIZED */) {
+            await this.session.reauth();
+            return this.httpClient.fetchJson(this.getOptionsWithSessionHeaders(options));
+        }
+        return response;
+    }
+    async fetchBlob(options) {
+        return this.httpClient.fetchBlob(this.getOptionsWithSessionHeaders(options));
+    }
+    getOptionsWithSessionHeaders(options) {
+        // Set headers if the session is newly created.
+        // This is needed only if the user is not logged in.
+        if (this.session.session.accessToken) {
+            options.headers.set('x-pm-uid', this.session.session.uid);
+            options.headers.set('Authorization', `Bearer ${this.session.session.accessToken}`);
+        }
+        return options;
+    }
+}
+exports.SharingPublicSessionHttpClient = SharingPublicSessionHttpClient;
+//# sourceMappingURL=httpClient.js.map

package/dist/internal/sharingPublic/session/httpClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpClient.js","sourceRoot":"","sources":["../../../../src/internal/sharingPublic/session/httpClient.ts"],"names":[],"mappings":";;;AAQA;;;;;GAKG;AACH,MAAa,8BAA8B;IAE3B;IACA;IAFZ,YACY,UAAiC,EACjC,OAAiC;QADjC,eAAU,GAAV,UAAU,CAAuB;QACjC,YAAO,GAAP,OAAO,CAA0B;QAEzC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IAC3B,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,OAAyC;QACrD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,4BAA4B,CAAC,OAAO,CAAC,CAAC,CAAC;QAE7F,IAAI,QAAQ,CAAC,MAAM,yCAA+B,EAAE,CAAC;YACjD,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,4BAA4B,CAAC,OAAO,CAAC,CAAC,CAAC;QACjF,CAAC;QAED,OAAO,QAAQ,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,SAAS,CAAC,OAAyC;QACrD,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,4BAA4B,CAAC,OAAO,CAAC,CAAC,CAAC;IACjF,CAAC;IAEO,4BAA4B,CAAC,OAAyC;QAC1E,+CAA+C;QAC/C,oDAAoD;QACpD,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;YACnC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAC1D,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,UAAU,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;QACvF,CAAC;QACD,OAAO,OAAO,CAAC;IACnB,CAAC;CACJ;AAjCD,wEAiCC"}

package/dist/internal/sharingPublic/session/index.d.ts

@@ -0,0 +1 @@
+export { SharingPublicSessionManager } from './manager';

package/dist/internal/sharingPublic/session/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharingPublicSessionManager = void 0;
+var manager_1 = require("./manager");
+Object.defineProperty(exports, "SharingPublicSessionManager", { enumerable: true, get: function () { return manager_1.SharingPublicSessionManager; } });
+//# sourceMappingURL=index.js.map

package/dist/internal/sharingPublic/session/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/internal/sharingPublic/session/index.ts"],"names":[],"mappings":";;;AAAA,qCAAwD;AAA/C,sHAAA,2BAA2B,OAAA"}

package/dist/internal/sharingPublic/session/interface.d.ts

@@ -0,0 +1,18 @@
+export type PublicLinkInfo = {
+    srp: PublicLinkSrpInfo;
+    isCustomPasswordProtected: boolean;
+    isLegacy: boolean;
+    vendorType: number;
+};
+export type PublicLinkSrpInfo = {
+    version: number;
+    modulus: string;
+    serverEphemeral: string;
+    salt: string;
+    srpSession: string;
+};
+export type PublicLinkSrpAuth = {
+    clientProof: string;
+    clientEphemeral: string;
+    srpSession: string;
+};

package/dist/internal/sharingPublic/session/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/dist/internal/sharingPublic/session/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.js","sourceRoot":"","sources":["../../../../src/internal/sharingPublic/session/interface.ts"],"names":[],"mappings":""}

package/dist/internal/sharingPublic/session/manager.d.ts

@@ -0,0 +1,49 @@
+import { ProtonDriveHTTPClient } from '../../../interface';
+import { SRPModule } from '../../../crypto';
+import { DriveAPIService } from '../../apiService';
+import { SharingPublicSessionHttpClient } from './httpClient';
+/**
+ * Manages sessions for public links.
+ *
+ * It can be used to get access to multiple public links.
+ */
+export declare class SharingPublicSessionManager {
+    private httpClient;
+    private srpModule;
+    private api;
+    private infosPerToken;
+    constructor(httpClient: ProtonDriveHTTPClient, apiService: DriveAPIService, srpModule: SRPModule);
+    /**
+     * Get the info for a public link.
+     *
+     * It returns the info for the public link, including if it is custom
+     * password protected, if it is legacy (not supported anymore), and
+     * the vendor type (whether it is Proton Docs, for example, and should
+     * be redirected to the public Docs app).
+     *
+     * @param url - The URL of the public link.
+     */
+    getInfo(url: string): Promise<{
+        isCustomPasswordProtected: boolean;
+        isLegacy: boolean;
+        vendorType: number;
+    }>;
+    /**
+     * Authenticate a public link session.
+     *
+     * It returns HTTP client that must be used for the endpoints to access the
+     * public link data.
+     *
+     * It returnes parsed token and full password (password from the URL +
+     * custom password) that can be used for decrypting the share key.
+     *
+     * @param url - The URL of the public link.
+     * @param customPassword - The custom password for the public link, if it is
+     * custom password protected.
+     */
+    auth(url: string, customPassword?: string): Promise<{
+        token: string;
+        password: string;
+        httpClient: SharingPublicSessionHttpClient;
+    }>;
+}

package/dist/internal/sharingPublic/session/manager.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharingPublicSessionManager = void 0;
+const apiService_1 = require("./apiService");
+const httpClient_1 = require("./httpClient");
+const session_1 = require("./session");
+const url_1 = require("./url");
+/**
+ * Manages sessions for public links.
+ *
+ * It can be used to get access to multiple public links.
+ */
+class SharingPublicSessionManager {
+    httpClient;
+    srpModule;
+    api;
+    infosPerToken = new Map();
+    constructor(httpClient, apiService, srpModule) {
+        this.httpClient = httpClient;
+        this.srpModule = srpModule;
+        this.httpClient = httpClient;
+        this.srpModule = srpModule;
+        this.api = new apiService_1.SharingPublicSessionAPIService(apiService);
+    }
+    /**
+     * Get the info for a public link.
+     *
+     * It returns the info for the public link, including if it is custom
+     * password protected, if it is legacy (not supported anymore), and
+     * the vendor type (whether it is Proton Docs, for example, and should
+     * be redirected to the public Docs app).
+     *
+     * @param url - The URL of the public link.
+     */
+    async getInfo(url) {
+        const { token } = (0, url_1.getTokenAndPasswordFromUrl)(url);
+        const info = await this.api.initPublicLinkSession(token);
+        this.infosPerToken.set(token, info);
+        return {
+            isCustomPasswordProtected: info.isCustomPasswordProtected,
+            isLegacy: info.isLegacy,
+            vendorType: info.vendorType,
+        };
+    }
+    /**
+     * Authenticate a public link session.
+     *
+     * It returns HTTP client that must be used for the endpoints to access the
+     * public link data.
+     *
+     * It returnes parsed token and full password (password from the URL +
+     * custom password) that can be used for decrypting the share key.
+     *
+     * @param url - The URL of the public link.
+     * @param customPassword - The custom password for the public link, if it is
+     * custom password protected.
+     */
+    async auth(url, customPassword) {
+        const { token, password: urlPassword } = (0, url_1.getTokenAndPasswordFromUrl)(url);
+        let info = this.infosPerToken.get(token);
+        if (!info) {
+            info = await this.api.initPublicLinkSession(token);
+        }
+        const password = `${urlPassword}${customPassword || ''}`;
+        const session = new session_1.SharingPublicLinkSession(this.api, this.srpModule, token, password);
+        await session.auth(info.srp);
+        return {
+            token,
+            password,
+            httpClient: new httpClient_1.SharingPublicSessionHttpClient(this.httpClient, session),
+        };
+    }
+}
+exports.SharingPublicSessionManager = SharingPublicSessionManager;
+//# sourceMappingURL=manager.js.map

package/dist/internal/sharingPublic/session/manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.js","sourceRoot":"","sources":["../../../../src/internal/sharingPublic/session/manager.ts"],"names":[],"mappings":";;;AAGA,6CAA8D;AAC9D,6CAA8D;AAE9D,uCAAqD;AACrD,+BAAmD;AAEnD;;;;GAIG;AACH,MAAa,2BAA2B;IAMxB;IAEA;IAPJ,GAAG,CAAiC;IAEpC,aAAa,GAAgC,IAAI,GAAG,EAAE,CAAC;IAE/D,YACY,UAAiC,EACzC,UAA2B,EACnB,SAAoB;QAFpB,eAAU,GAAV,UAAU,CAAuB;QAEjC,cAAS,GAAT,SAAS,CAAW;QAE5B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAE3B,IAAI,CAAC,GAAG,GAAG,IAAI,2CAA8B,CAAC,UAAU,CAAC,CAAC;IAC9D,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,OAAO,CAAC,GAAW;QAKrB,MAAM,EAAE,KAAK,EAAE,GAAG,IAAA,gCAA0B,EAAC,GAAG,CAAC,CAAC;QAElD,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;QACzD,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAEpC,OAAO;YACH,yBAAyB,EAAE,IAAI,CAAC,yBAAyB;YACzD,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,UAAU,EAAE,IAAI,CAAC,UAAU;SAC9B,CAAC;IACN,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,IAAI,CACN,GAAW,EACX,cAAuB;QAMvB,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,IAAA,gCAA0B,EAAC,GAAG,CAAC,CAAC;QAEzE,IAAI,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACzC,IAAI,CAAC,IAAI,EAAE,CAAC;YACR,IAAI,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;QACvD,CAAC;QAED,MAAM,QAAQ,GAAG,GAAG,WAAW,GAAG,cAAc,IAAI,EAAE,EAAE,CAAC;QAEzD,MAAM,OAAO,GAAG,IAAI,kCAAwB,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;QACxF,MAAM,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAE7B,OAAO;YACH,KAAK;YACL,QAAQ;YACR,UAAU,EAAE,IAAI,2CAA8B,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC;SAC3E,CAAC;IACN,CAAC;CACJ;AAlFD,kEAkFC"}

package/dist/internal/sharingPublic/session/session.d.ts

@@ -0,0 +1,34 @@
+import { SRPModule } from "../../../crypto";
+import { SharingPublicSessionAPIService } from "./apiService";
+import { PublicLinkInfo, PublicLinkSrpInfo } from "./interface";
+/**
+ * Session for a public link.
+ *
+ * It is responsible for initializing and authenticating the public link session
+ * with the SRP handshake. It also can re-authenticate the session if it is expired.
+ */
+export declare class SharingPublicLinkSession {
+    private apiService;
+    private srpModule;
+    private token;
+    private password;
+    private sessionUid?;
+    private sessionAccessToken?;
+    constructor(apiService: SharingPublicSessionAPIService, srpModule: SRPModule, token: string, password: string);
+    reauth(): Promise<void>;
+    init(): Promise<PublicLinkInfo>;
+    auth(srp: PublicLinkSrpInfo): Promise<void>;
+    /**
+     * Get the session uid and access token.
+     *
+     * The access token is only returned if the session is newly created.
+     * If the access token is not available, it means the existing session
+     * can be used to access the public link.
+     *
+     * @throws If the session is not initialized.
+     */
+    get session(): {
+        uid: string;
+        accessToken: string | undefined;
+    };
+}