@protontech/drive-sdk 0.3.0 → 0.3.2

package/src/internal/sharing/sharingManagement.test.ts

@@ -10,12 +10,14 @@ import {
     resultOk,
 } from '../../interface';
 import { SharingAPIService } from './apiService';
+import { SharingCache } from './cache';
 import { SharingCryptoService } from './cryptoService';
 import { SharesService, NodesService } from './interface';
 import { SharingManagement } from './sharingManagement';
 
 describe('SharingManagement', () => {
     let apiService: SharingAPIService;
+    let cache: SharingCache;
     let cryptoService: SharingCryptoService;
     let accountService: ProtonDriveAccount;
     let sharesService: SharesService;
@@ -57,6 +59,12 @@ describe('SharingManagement', () => {
             updatePublicLink: jest.fn(),
         };
         // @ts-expect-error No need to implement all methods for mocking
+        cache = {
+            hasSharedByMeNodeUidsLoaded: jest.fn().mockResolvedValue(true),
+            addSharedByMeNodeUid: jest.fn(),
+            removeSharedByMeNodeUid: jest.fn(),
+        };
+        // @ts-expect-error No need to implement all methods for mocking
         cryptoService = {
             generateShareKeys: jest.fn().mockResolvedValue({
                 shareKey: { encrypted: 'encrypted-key', decrypted: { passphraseSessionKey: 'pass-session-key' } },
@@ -104,6 +112,7 @@ describe('SharingManagement', () => {
         sharingManagement = new SharingManagement(
             getMockLogger(),
             apiService,
+            cache,
             cryptoService,
             accountService,
             sharesService,
@@ -214,6 +223,7 @@ describe('SharingManagement', () => {
             expect(apiService.updateInvitation).not.toHaveBeenCalled();
             expect(apiService.inviteProtonUser).toHaveBeenCalled();
             expect(nodesService.notifyNodeChanged).toHaveBeenCalledWith(nodeUid);
+            expect(cache.addSharedByMeNodeUid).toHaveBeenCalledWith(nodeUid);
         });
     });
 
@@ -279,6 +289,7 @@ describe('SharingManagement', () => {
                 });
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).toHaveBeenCalled();
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
             it('should share node with proton email with specific role', async () => {
@@ -302,6 +313,7 @@ describe('SharingManagement', () => {
                 });
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).toHaveBeenCalled();
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
             it('should update existing role', async () => {
@@ -322,6 +334,7 @@ describe('SharingManagement', () => {
                 });
                 expect(apiService.updateInvitation).toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
             it('should be no-op if no change', async () => {
@@ -337,6 +350,7 @@ describe('SharingManagement', () => {
                 });
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
             it('should use address from the root node context share', async () => {
@@ -383,6 +397,7 @@ describe('SharingManagement', () => {
                 });
                 expect(apiService.updateExternalInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteExternalUser).toHaveBeenCalled();
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
             it('should share node with external email with specific role', async () => {
@@ -407,6 +422,7 @@ describe('SharingManagement', () => {
                 });
                 expect(apiService.updateExternalInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteExternalUser).toHaveBeenCalled();
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
             it('should update existing role', async () => {
@@ -427,6 +443,7 @@ describe('SharingManagement', () => {
                 });
                 expect(apiService.updateExternalInvitation).toHaveBeenCalled();
                 expect(apiService.inviteExternalUser).not.toHaveBeenCalled();
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
             it('should be no-op if no change', async () => {
@@ -442,6 +459,7 @@ describe('SharingManagement', () => {
                 });
                 expect(apiService.updateExternalInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteExternalUser).not.toHaveBeenCalled();
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
             it('should use address from the root node context share', async () => {
@@ -512,6 +530,7 @@ describe('SharingManagement', () => {
                     }),
                     expect.anything(),
                 );
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
         });
 
@@ -535,6 +554,7 @@ describe('SharingManagement', () => {
                 expect(apiService.updateMember).toHaveBeenCalled();
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
             it('should be no-op if no change via proton user', async () => {
@@ -551,6 +571,7 @@ describe('SharingManagement', () => {
                 expect(apiService.updateMember).not.toHaveBeenCalled();
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
             it('should update member via non-proton user', async () => {
@@ -572,6 +593,7 @@ describe('SharingManagement', () => {
                 expect(apiService.updateMember).toHaveBeenCalled();
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
             it('should be no-op if no change via non-proton user', async () => {
@@ -588,6 +610,7 @@ describe('SharingManagement', () => {
                 expect(apiService.updateMember).not.toHaveBeenCalled();
                 expect(apiService.updateInvitation).not.toHaveBeenCalled();
                 expect(apiService.inviteProtonUser).not.toHaveBeenCalled();
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
         });
 
@@ -635,6 +658,7 @@ describe('SharingManagement', () => {
                         srp: 'publicLinkSrp',
                     }),
                 );
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
             it('should share node with custom password and expiration', async () => {
@@ -680,6 +704,7 @@ describe('SharingManagement', () => {
                         srp: 'publicLinkSrp',
                     }),
                 );
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
             it('should update public link with custom password and expiration', async () => {
@@ -734,6 +759,7 @@ describe('SharingManagement', () => {
                         srp: 'publicLinkSrp',
                     }),
                 );
+                expect(cache.addSharedByMeNodeUid).not.toHaveBeenCalled();
             });
 
             it('should not allow updating legacy public link', async () => {
@@ -839,6 +865,7 @@ describe('SharingManagement', () => {
             expect(apiService.deleteExternalInvitation).not.toHaveBeenCalled();
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
+            expect(cache.removeSharedByMeNodeUid).not.toHaveBeenCalled();
         });
 
         it('should delete external invitation', async () => {
@@ -855,6 +882,7 @@ describe('SharingManagement', () => {
             expect(apiService.deleteExternalInvitation).toHaveBeenCalled();
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
+            expect(cache.removeSharedByMeNodeUid).not.toHaveBeenCalled();
         });
 
         it('should remove member', async () => {
@@ -871,6 +899,7 @@ describe('SharingManagement', () => {
             expect(apiService.deleteExternalInvitation).not.toHaveBeenCalled();
             expect(apiService.removeMember).toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
+            expect(cache.removeSharedByMeNodeUid).not.toHaveBeenCalled();
         });
 
         it('should be no-op if not shared with email', async () => {
@@ -887,6 +916,7 @@ describe('SharingManagement', () => {
             expect(apiService.deleteExternalInvitation).not.toHaveBeenCalled();
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
+            expect(cache.removeSharedByMeNodeUid).not.toHaveBeenCalled();
         });
 
         it('should remove public link', async () => {
@@ -903,6 +933,7 @@ describe('SharingManagement', () => {
             expect(apiService.deleteExternalInvitation).not.toHaveBeenCalled();
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).toHaveBeenCalled();
+            expect(cache.removeSharedByMeNodeUid).not.toHaveBeenCalled();
         });
 
         it('should remove share if all is removed', async () => {
@@ -915,6 +946,7 @@ describe('SharingManagement', () => {
             expect(apiService.removeMember).not.toHaveBeenCalled();
             expect(apiService.removePublicLink).not.toHaveBeenCalled();
             expect(nodesService.notifyNodeChanged).toHaveBeenCalled();
+            expect(cache.removeSharedByMeNodeUid).toHaveBeenCalledWith(nodeUid);
         });
 
         it('should remove share if everything is manually removed', async () => {
@@ -929,6 +961,7 @@ describe('SharingManagement', () => {
             expect(apiService.deleteExternalInvitation).toHaveBeenCalled();
             expect(apiService.removeMember).toHaveBeenCalled();
             expect(apiService.removePublicLink).toHaveBeenCalled();
+            expect(cache.removeSharedByMeNodeUid).toHaveBeenCalledWith(nodeUid);
         });
     });
 

package/src/internal/sharing/sharingManagement.ts

@@ -20,6 +20,7 @@ import { getErrorMessage } from '../errors';
 import { SharingAPIService } from './apiService';
 import { PUBLIC_LINK_GENERATED_PASSWORD_LENGTH, SharingCryptoService } from './cryptoService';
 import { SharesService, NodesService, ShareResultWithCreatorEmail, PublicLinkWithCreatorEmail } from './interface';
+import { SharingCache } from './cache';
 
 interface InternalShareResult extends ShareResultWithCreatorEmail {
     share: Share;
@@ -54,6 +55,7 @@ export class SharingManagement {
     constructor(
         private logger: Logger,
         private apiService: SharingAPIService,
+        private cache: SharingCache,
         private cryptoService: SharingCryptoService,
         private account: ProtonDriveAccount,
         private sharesService: SharesService,
@@ -61,6 +63,7 @@ export class SharingManagement {
     ) {
         this.logger = logger;
         this.apiService = apiService;
+        this.cache = cache;
         this.cryptoService = cryptoService;
         this.account = account;
         this.sharesService = sharesService;
@@ -409,6 +412,9 @@ export class SharingManagement {
             base64NameKeyPacket: keys.base64NameKeyPacket,
         });
         await this.nodesService.notifyNodeChanged(nodeUid);
+        if (await this.cache.hasSharedByMeNodeUidsLoaded()) {
+            await this.cache.addSharedByMeNodeUid(nodeUid);
+        }
 
         const share = {
             volumeId,
@@ -430,6 +436,9 @@ export class SharingManagement {
     private async deleteShare(shareId: string, nodeUid: string): Promise<void> {
         await this.apiService.deleteShare(shareId);
         await this.nodesService.notifyNodeChanged(nodeUid);
+        if (await this.cache.hasSharedByMeNodeUidsLoaded()) {
+            await this.cache.removeSharedByMeNodeUid(nodeUid);
+        }
     }
 
     private async inviteProtonUser(

package/src/internal/sharingPublic/apiService.ts

@@ -0,0 +1,173 @@
+import { DriveAPIService, drivePaths, nodeTypeNumberToNodeType } from '../apiService';
+import { Logger, MemberRole } from '../../interface';
+import { makeNodeUid, splitNodeUid } from '../uids';
+import { EncryptedShareCrypto, EncryptedNode } from './interface';
+
+const PAGE_SIZE = 50;
+
+type GetTokenInfoResponse = drivePaths['/drive/urls/{token}']['get']['responses']['200']['content']['application/json'];
+
+type GetTokenFolderChildrenResponse =
+    drivePaths['/drive/urls/{token}/folders/{linkID}/children']['get']['responses']['200']['content']['application/json'];
+
+/**
+ * Provides API communication for accessing public link data.
+ *
+ * The service is responsible for transforming local objects to API payloads
+ * and vice versa. It should not contain any business logic.
+ */
+export class SharingPublicAPIService {
+    constructor(
+        private logger: Logger,
+        private apiService: DriveAPIService,
+    ) {
+        this.logger = logger;
+        this.apiService = apiService;
+    }
+
+    async getPublicLinkRoot(token: string): Promise<{
+        encryptedNode: EncryptedNode;
+        encryptedShare: EncryptedShareCrypto;
+    }> {
+        const response = await this.apiService.get<GetTokenInfoResponse>(`drive/urls/${token}`);
+        const encryptedNode = tokenToEncryptedNode(this.logger, response.Token);
+
+        return {
+            encryptedNode: encryptedNode,
+            encryptedShare: {
+                base64UrlPasswordSalt: response.Token.SharePasswordSalt,
+                armoredKey: response.Token.ShareKey,
+                armoredPassphrase: response.Token.SharePassphrase,
+            },
+        };
+    }
+
+    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) {
+                yield linkToEncryptedNode(this.logger, token, link);
+            }
+
+            if (response.Links.length < PAGE_SIZE) {
+                break;
+            }
+            page++;
+        }
+    }
+}
+
+function tokenToEncryptedNode(logger: Logger, token: GetTokenInfoResponse['Token']): EncryptedNode {
+    const baseNodeMetadata = {
+        // Internal metadata
+        encryptedName: token.Name,
+
+        // Basic node metadata
+        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 = {
+        signatureEmail: token.SignatureEmail || undefined,
+        armoredKey: token.NodeKey,
+        armoredNodePassphrase: token.NodePassphrase,
+        armoredNodePassphraseSignature: token.NodePassphraseSignature || undefined,
+    };
+
+    if (token.LinkType === 1 && token.NodeHashKey) {
+        return {
+            ...baseNodeMetadata,
+            encryptedCrypto: {
+                ...baseCryptoNodeMetadata,
+                folder: {
+                    armoredHashKey: token.NodeHashKey as string,
+                },
+            },
+        };
+    }
+
+    if (token.LinkType === 2 && token.ContentKeyPacket) {
+        return {
+            ...baseNodeMetadata,
+            totalStorageSize: token.Size || undefined,
+            mediaType: token.MIMEType || undefined,
+            encryptedCrypto: {
+                ...baseCryptoNodeMetadata,
+                file: {
+                    base64ContentKeyPacket: token.ContentKeyPacket,
+                },
+            },
+        };
+    }
+
+    throw new Error(`Unknown node type: ${token.LinkType}`);
+}
+
+function linkToEncryptedNode(
+    logger: Logger,
+    token: string,
+    link: GetTokenFolderChildrenResponse['Links'][0],
+): EncryptedNode {
+    const baseNodeMetadata = {
+        // Internal metadata
+        hash: link.Hash || undefined,
+        encryptedName: link.Name,
+
+        // Basic node metadata
+        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 = {
+        signatureEmail: link.SignatureEmail || undefined,
+        armoredKey: link.NodeKey,
+        armoredNodePassphrase: link.NodePassphrase,
+        armoredNodePassphraseSignature: link.NodePassphraseSignature || undefined,
+    };
+
+    if (link.Type === 1 && link.FolderProperties) {
+        return {
+            ...baseNodeMetadata,
+            encryptedCrypto: {
+                ...baseCryptoNodeMetadata,
+                folder: {
+                    armoredHashKey: link.FolderProperties.NodeHashKey as string,
+                },
+            },
+        };
+    }
+
+    if (link.Type === 2 && link.FileProperties?.ContentKeyPacket) {
+        return {
+            ...baseNodeMetadata,
+            totalStorageSize: link.FileProperties.ActiveRevision?.Size || undefined,
+            mediaType: link.MIMEType || undefined,
+            encryptedCrypto: {
+                ...baseCryptoNodeMetadata,
+                file: {
+                    base64ContentKeyPacket: link.FileProperties.ContentKeyPacket,
+                },
+            },
+        };
+    }
+
+    throw new Error(`Unknown node type: ${link.Type}`);
+}

package/src/internal/sharingPublic/cryptoCache.ts

@@ -0,0 +1,79 @@
+import { PrivateKey } from '../../crypto';
+import { ProtonDriveCryptoCache, Logger } from '../../interface';
+import { DecryptedNodeKeys } from './interface';
+
+/**
+ * Provides caching for public link crypto material.
+ *
+ * The cache is responsible for serialising and deserialising public link
+ * crypto material.
+ */
+export class SharingPublicCryptoCache {
+    constructor(
+        private logger: Logger,
+        private driveCache: ProtonDriveCryptoCache,
+    ) {
+        this.logger = logger;
+        this.driveCache = driveCache;
+    }
+
+    async setShareKey(shareKey: PrivateKey): Promise<void> {
+        await this.driveCache.setEntity(getShareKeyCacheKey(), {
+            publicShareKey: {
+                key: shareKey,
+            },
+        });
+    }
+
+    async getShareKey(): Promise<PrivateKey> {
+        const shareKeyData = await this.driveCache.getEntity(getShareKeyCacheKey());
+        if (!shareKeyData.publicShareKey) {
+            try {
+                await this.driveCache.removeEntities([getShareKeyCacheKey()]);
+            } catch (removingError: unknown) {
+                this.logger.warn(
+                    `Failed to remove corrupted public share key from the cache: ${removingError instanceof Error ? removingError.message : removingError}`,
+                );
+            }
+            throw new Error('Failed to deserialize public share key');
+        }
+        return shareKeyData.publicShareKey.key;
+    }
+
+    async setNodeKeys(nodeUid: string, keys: DecryptedNodeKeys): Promise<void> {
+        const cacheUid = getNodeCacheKey(nodeUid);
+        await this.driveCache.setEntity(cacheUid, {
+            nodeKeys: keys,
+        });
+    }
+
+    async getNodeKeys(nodeUid: string): Promise<DecryptedNodeKeys> {
+        const nodeKeysData = await this.driveCache.getEntity(getNodeCacheKey(nodeUid));
+        if (!nodeKeysData.nodeKeys) {
+            try {
+                await this.removeNodeKeys([nodeUid]);
+            } catch (removingError: unknown) {
+                // The node keys will not be returned, thus SDK will re-fetch
+                // and re-cache it. Setting it again should then fix the problem.
+                this.logger.warn(
+                    `Failed to remove corrupted public node keys from the cache: ${removingError instanceof Error ? removingError.message : removingError}`,
+                );
+            }
+            throw new Error(`Failed to deserialize public node keys`);
+        }
+        return nodeKeysData.nodeKeys;
+    }
+
+    async removeNodeKeys(nodeUids: string[]): Promise<void> {
+        const cacheUids = nodeUids.map(getNodeCacheKey);
+        await this.driveCache.removeEntities(cacheUids);
+    }
+}
+
+function getShareKeyCacheKey() {
+    return 'publicShareKey';
+}
+
+function getNodeCacheKey(nodeUid: string) {
+    return `publicNodeKeys-${nodeUid}`;
+}

package/src/internal/sharingPublic/cryptoService.ts

@@ -0,0 +1,98 @@
+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(
+        telemetry: ProtonDriveTelemetry,
+        driveCrypto: DriveCrypto,
+        account: ProtonDriveAccount,
+        private password: string,
+    ) {
+        super(telemetry, driveCrypto, account, new SharingPublicCryptoReporter(telemetry));
+        this.password = password;
+    }
+
+    async decryptPublicLinkShareKey(encryptedShare: EncryptedShareCrypto): Promise<PrivateKey> {
+        const { key: shareKey } = await this.driveCrypto.decryptKeyWithSrpPassword(
+            this.password,
+            encryptedShare.base64UrlPasswordSalt,
+            encryptedShare.armoredKey,
+            encryptedShare.armoredPassphrase,
+        );
+        return shareKey;
+    }
+}
+
+class SharingPublicCryptoReporter {
+    private logger: Logger;
+    private telemetry: ProtonDriveTelemetry;
+
+    constructor(telemetry: ProtonDriveTelemetry) {
+        this.telemetry = telemetry;
+        this.logger = telemetry.getLogger('sharingPublic-crypto');
+    }
+
+    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 resultError({
+            claimedAuthor,
+            error: !claimedAuthor
+                ? c('Info').t`Author is not provided on public link`
+                : getVerificationMessage(verified, verificationErrors, signatureType, notAvailableVerificationKeys),
+        });
+    }
+
+    reportDecryptionError(
+        node: { uid: string; creationTime: Date },
+        field: MetricsDecryptionErrorField,
+        error: unknown,
+    ) {
+        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: 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.
+    }
+}

package/src/internal/sharingPublic/index.ts

@@ -0,0 +1,41 @@
+import { DriveCrypto } from '../../crypto';
+import { ProtonDriveCryptoCache, ProtonDriveTelemetry, ProtonDriveAccount } from '../../interface';
+import { DriveAPIService } from '../apiService';
+import { SharingPublicAPIService } from './apiService';
+import { SharingPublicCryptoCache } from './cryptoCache';
+import { SharingPublicCryptoService } from './cryptoService';
+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 function initSharingPublicModule(
+    telemetry: ProtonDriveTelemetry,
+    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(telemetry, driveCrypto, account, password);
+    const manager = new SharingPublicManager(
+        telemetry.getLogger('sharingPublic-nodes'),
+        api,
+        cryptoCache,
+        cryptoService,
+        token,
+    );
+
+    return manager;
+}

package/src/internal/sharingPublic/interface.ts

@@ -0,0 +1,14 @@
+// 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;
+}