π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
import { decryptBox, decryptMetadataJSON, deriveKey } from "ente-base/crypto";
import { fetchPublicCollectionFile } from "ente-base/file-download";
import {
authenticatedPublicAlbumsDeviceLimitRequestHeaders,
authenticatedPublicAlbumsInfoRequestHeaders,
authenticatedPublicAlbumsRequestHeaders,
ensureOk,
linkDeviceTokenFromResponse,
type PublicAlbumsCredentials,
} from "ente-base/http";
import { apiURL } from "ente-base/origins";
import {
decryptRemoteCollection,
RemoteCollection,
type PublicURL,
} from "ente-media/collection";
import { FileDiffResponse, type RemoteEnteFile } from "ente-media/file";
import { z } from "zod";
import type { DecryptedFileInfo, LockerInfoData } from "../types/file-share";
import { saveStreamedFile, type DownloadProgress } from "./download";
interface ParsedLockerInfoData extends LockerInfoData {
title?: string;
name?: string;
}
interface ParsedLockerInfo {
type?: string;
data?: ParsedLockerInfoData;
}
export interface SharedCollectionItemInfo extends DecryptedFileInfo {
collectionID: number;
hasObject: boolean;
}
export interface PublicCollectionShareInfo {
id: number;
name: string;
allowDownload: boolean;
items: SharedCollectionItemInfo[];
}
export interface PublicCollectionShareMetadata {
id: number;
name: string;
allowDownload: boolean;
passwordEnabled: boolean;
publicURL?: PublicURL;
collectionKey: string;
linkDeviceToken?: string;
}
const VALID_INFO_TYPES = new Set([
"note",
"accountCredential",
"physicalRecord",
"emergencyContact",
]);
const normalizeLockerInfoType = (
type: string | undefined,
): string | undefined => {
switch (type) {
case "note":
return "note";
case "physical-record":
case "physicalRecord":
return "physicalRecord";
case "account-credential":
case "accountCredential":
return "accountCredential";
case "emergency-contact":
case "emergencyContact":
return "emergencyContact";
default:
return undefined;
}
};
const infoItemTitle = (
infoType: string,
infoData: ParsedLockerInfoData,
): string => {
const namedTitle = infoData.title?.trim() || infoData.name?.trim();
if (namedTitle) {
return namedTitle;
}
switch (infoType) {
case "note":
return "Note";
case "physicalRecord":
return "Location";
case "accountCredential":
return "Secret";
case "emergencyContact":
return "Emergency Contact";
default:
return "Item";
}
};
const toUploadedTime = (value: unknown, fallback: number) => {
if (typeof value !== "number") {
return fallback;
}
return value < 100_000_000_000_000 ? value * 1000 : value;
};
const parseLockerInfo = (rawInfo: unknown): ParsedLockerInfo | undefined => {
if (!rawInfo) return undefined;
const parsedInfo = (() => {
if (typeof rawInfo === "string") {
try {
return JSON.parse(rawInfo) as ParsedLockerInfo;
} catch {
return undefined;
}
}
if (typeof rawInfo === "object") {
return rawInfo as ParsedLockerInfo;
}
return undefined;
})();
if (!parsedInfo) {
return undefined;
}
return { ...parsedInfo, type: normalizeLockerInfoType(parsedInfo.type) };
};
const decryptRemoteFileToCollectionItem = async (
remoteFile: RemoteEnteFile,
collectionKey: string,
): Promise<SharedCollectionItemInfo> => {
const fileKey = await decryptBox(
{
encryptedData: remoteFile.encryptedKey,
nonce: remoteFile.keyDecryptionNonce,
},
collectionKey,
);
const metadata = (await decryptMetadataJSON(
remoteFile.metadata,
fileKey,
)) as Record<string, unknown> | undefined;
let pubMagicMetadata: Record<string, unknown> | undefined;
if (remoteFile.pubMagicMetadata) {
try {
pubMagicMetadata = (await decryptMetadataJSON(
{
encryptedData: remoteFile.pubMagicMetadata.data,
decryptionHeader: remoteFile.pubMagicMetadata.header,
},
fileKey,
)) as Record<string, unknown> | undefined;
} catch {
pubMagicMetadata = undefined;
}
}
const info = parseLockerInfo(pubMagicMetadata?.info);
const isStructured =
!!info?.type && !!info.data && VALID_INFO_TYPES.has(info.type);
if (isStructured) {
return {
id: remoteFile.id,
collectionID: remoteFile.collectionID,
fileName: infoItemTitle(info.type!, info.data!),
fileSize: info.data?.size ?? 0,
uploadedTime: toUploadedTime(
metadata?.creationTime,
remoteFile.updationTime,
),
fileKey,
lockerType: info.type,
lockerInfoData: info.data,
hasObject: false,
};
}
const metadataName =
typeof metadata?.title === "string"
? metadata.title
: typeof metadata?.fileName === "string"
? metadata.fileName
: typeof metadata?.name === "string"
? metadata.name
: undefined;
const editedName =
typeof pubMagicMetadata?.editedName === "string"
? pubMagicMetadata.editedName
: undefined;
return {
id: remoteFile.id,
collectionID: remoteFile.collectionID,
fileName: editedName ?? metadataName ?? "File",
fileSize:
remoteFile.info?.fileSize ??
(typeof metadata?.fileSize === "number"
? metadata.fileSize
: typeof metadata?.size === "number"
? metadata.size
: 0),
uploadedTime: toUploadedTime(
metadata?.creationTime,
remoteFile.updationTime,
),
fileDecryptionHeader: remoteFile.file.decryptionHeader,
fileKey,
hasObject: remoteFile.file.decryptionHeader.length > 0,
};
};
const fetchPublicCollectionDiff = async (
credentials: PublicAlbumsCredentials,
) => {
const filesByID = new Map<number, RemoteEnteFile>();
let sinceTime = 0;
let hasMore = true;
while (hasMore) {
const prevSinceTime = sinceTime;
const res = await fetch(
await apiURL("/public-collection/diff", { sinceTime }),
{
headers:
authenticatedPublicAlbumsDeviceLimitRequestHeaders(
credentials,
),
cache: "no-store",
},
);
ensureOk(res);
const parsed = FileDiffResponse.parse(await res.json());
for (const file of parsed.diff) {
sinceTime = Math.max(sinceTime, file.updationTime);
if (file.isDeleted) {
filesByID.delete(file.id);
} else {
filesByID.set(file.id, file);
}
}
hasMore = parsed.hasMore;
// Stop when the server claims more pages but sinceTime did not
// advance, to avoid looping forever on a broken pagination contract.
if (hasMore && sinceTime === prevSinceTime) break;
}
return [...filesByID.values()];
};
export const verifyPublicCollectionPassword = async (
publicURL: PublicURL,
password: string,
accessToken: string,
) => {
const passwordHash = await deriveKey(
password,
publicURL.nonce!,
publicURL.opsLimit!,
publicURL.memLimit!,
);
const res = await fetch(
await apiURL("/public-collection/verify-password"),
{
method: "POST",
headers: authenticatedPublicAlbumsRequestHeaders({ accessToken }),
body: JSON.stringify({ passHash: passwordHash }),
},
);
ensureOk(res);
return z.object({ jwtToken: z.string() }).parse(await res.json()).jwtToken;
};
export const fetchPublicCollectionShareMetadata = async (
credentials: PublicAlbumsCredentials,
collectionKey: string,
): Promise<PublicCollectionShareMetadata> => {
const res = await fetch(await apiURL("/public-collection/info"), {
headers: authenticatedPublicAlbumsInfoRequestHeaders(credentials),
cache: "no-store",
});
ensureOk(res);
const data = (await res.json()) as { collection: unknown };
const remoteCollection = RemoteCollection.parse(data.collection);
const collection = await decryptRemoteCollection(
remoteCollection,
collectionKey,
);
const publicURL = collection.publicURLs[0];
return {
id: collection.id,
name: collection.name,
allowDownload: publicURL?.enableDownload ?? true,
passwordEnabled: publicURL?.passwordEnabled ?? false,
publicURL,
collectionKey: collection.key,
linkDeviceToken: linkDeviceTokenFromResponse(res),
};
};
export const fetchPublicCollectionShare = async (
credentials: PublicAlbumsCredentials,
metadata: PublicCollectionShareMetadata,
): Promise<PublicCollectionShareInfo> => {
const remoteFiles = await fetchPublicCollectionDiff(credentials);
const items = await Promise.all(
remoteFiles.map((file) =>
decryptRemoteFileToCollectionItem(file, metadata.collectionKey),
),
);
items.sort((a, b) => b.uploadedTime - a.uploadedTime);
return {
id: metadata.id,
name: metadata.name,
allowDownload: metadata.allowDownload,
items,
};
};
export const downloadPublicCollectionFile = async (
credentials: PublicAlbumsCredentials,
fileID: number,
fileKey: string,
fileName: string,
fileDecryptionHeader: string,
onProgress?: (progress: DownloadProgress) => void,
): Promise<void> => {
const response = await fetchPublicCollectionFile(
fileID,
"file",
credentials,
);
ensureOk(response);
await saveStreamedFile(
response,
fileKey,
fileName,
fileDecryptionHeader,
onProgress,
);
};