[PB-6503] Add download with bucketKey

src/network/download.ts

@@ -7,6 +7,7 @@ import {
   DownloadFileFunction,
   ToBinaryDataFunction,
   BinaryData,
+  CryptoWithBucketKey,
 } from './types';
 
 export class FileVersionOneError extends Error {
@@ -71,3 +72,50 @@ export async function downloadFile(
     throw err;
   }
 }
+
+export async function downloadFileWithBucketKey(
+  fileId: string,
+  bucketId: string,
+  bucketKey: Buffer,
+  network: Network,
+  crypto: CryptoWithBucketKey,
+  toBinaryData: ToBinaryDataFunction,
+  downloadFile: DownloadFileFunction,
+  decryptFile: DecryptFileFunction,
+  opts?: { token: string },
+): Promise<void> {
+  let iv: BinaryData;
+  let key: BinaryData;
+
+  try {
+    const fileInfo = await network.getDownloadLinks(bucketId, fileId, opts?.token);
+    const { index, shards, version, size } = fileInfo;
+
+    if (!version || version === 1) {
+      throw new FileVersionOneError();
+    }
+
+    iv = toBinaryData(index, BinaryDataEncoding.HEX).slice(0, 16);
+    key = await crypto.generateFileKeyFromBucketKey(bucketKey, toBinaryData(index, BinaryDataEncoding.HEX));
+    const downloadables = shards.sort((sA, sB) => sA.index - sB.index);
+
+    await downloadFile(downloadables, fileInfo);
+    await decryptFile(crypto.algorithm.type, key, iv, size);
+  } catch (err) {
+    const context = getNetworkErrorContext(
+      {
+        bucketId,
+        fileId,
+        user: network.credentials.username,
+        crypto: {
+          bucketKey,
+        },
+      },
+      err,
+    );
+
+    (err as ErrorWithContext).context = context;
+
+    throw err;
+  }
+}

src/network/errors/context.ts

@@ -7,6 +7,7 @@ export type NetworkUploadContext = {
   user: string;
   crypto: {
     mnemonic?: string;
+    bucketKey?: Buffer;
   };
 };
 export type NetworkDownloadContext = {
@@ -15,6 +16,7 @@ export type NetworkDownloadContext = {
   user: string;
   crypto: {
     mnemonic?: string;
+    bucketKey?: Buffer;
   };
 };
 
@@ -30,9 +32,11 @@ export function getNetworkErrorContext(input: NetworkContext, err: unknown): Net
   const output = Object.assign({}, input);
 
   delete output.crypto.mnemonic;
+  delete output.crypto.bucketKey;
 
   if (err instanceof UploadInvalidMnemonicError || err instanceof DownloadInvalidMnemonicError) {
     output.crypto.mnemonic = input.crypto.mnemonic;
+    output.crypto.bucketKey = input.crypto.bucketKey;
   }
 
   return output;

src/network/types.ts

@@ -119,14 +119,21 @@ export const ALGORITHMS: Record<SymmetricCryptoAlgorithm, Algorithm> = {
   },
 };
 
-export type Crypto = {
+type CryptoBase = {
   algorithm: Algorithm;
-  validateMnemonic: (mnemonic: string) => boolean;
   randomBytes: (bytesLength: number) => BinaryData;
-  generateFileKey: (mnemonic: string, bucketId: string, index: BinaryData | string) => Promise<BinaryData>;
   computeHmac?: (key: BinaryData, shardHashes: string[]) => Promise<HmacPayload>;
 };
 
+export type Crypto = CryptoBase & {
+  validateMnemonic: (mnemonic: string) => boolean;
+  generateFileKey: (mnemonic: string, bucketId: string, index: BinaryData | string) => Promise<BinaryData>;
+};
+
+export type CryptoWithBucketKey = CryptoBase & {
+  generateFileKeyFromBucketKey: (bucketKey: Buffer, index: BinaryData) => Promise<BinaryData>;
+};
+
 export type EncryptFileFunction = (
   algorithm: SymmetricCryptoAlgorithm,
   key: BinaryData,