Skip to content

armgit / ente

Public Imported from GitHub
0

💚 End-to-end encrypted cloud for everything.

Pass payload bytes directly across WASM boundaries

Manav Rathid6fb68282491
diff --git a/rust/bindings/wasm/lib/src/crypto.rs b/rust/bindings/wasm/lib/src/crypto.rs
index c85f5728b5..6c1551f1b1 100644
--- a/rust/bindings/wasm/lib/src/crypto.rs
+++ b/rust/bindings/wasm/lib/src/crypto.rs
@@ -44,9 +44,13 @@ pub fn crypto_generate_key() -> String {
#[wasm_bindgen(js_name = cryptoEncryptBox)]
pub fn crypto_encrypt_box(data_b64: &str, key_b64: &str) -> Result<EncryptedBox, Error> {
- let data = b64::decode(data_b64)?;
+ crypto_encrypt_box_bytes(&b64::decode(data_b64)?, key_b64)
+}
+
+#[wasm_bindgen(js_name = cryptoEncryptBoxBytes)]
+pub fn crypto_encrypt_box_bytes(data: &[u8], key_b64: &str) -> Result<EncryptedBox, Error> {
let key = b64::decode(key_b64)?;
- Ok(crypto::secretbox::encrypt(&data, &crypto::Key::try_from_slice(&key)?).into())
+ Ok(crypto::secretbox::encrypt(data, &crypto::Key::try_from_slice(&key)?).into())
}
#[wasm_bindgen(js_name = cryptoDecryptBox)]
@@ -55,16 +59,28 @@ pub fn crypto_decrypt_box(
nonce_b64: &str,
key_b64: &str,
) -> Result<String, Error> {
+ Ok(b64::encode(&crypto_decrypt_box_bytes(
+ encrypted_data_b64,
+ nonce_b64,
+ key_b64,
+ )?))
+}
+
+#[wasm_bindgen(js_name = cryptoDecryptBoxBytes)]
+pub fn crypto_decrypt_box_bytes(
+ encrypted_data_b64: &str,
+ nonce_b64: &str,
+ key_b64: &str,
+) -> Result<Vec<u8>, Error> {
let ciphertext = b64::decode(encrypted_data_b64)?;
let nonce = b64::decode(nonce_b64)?;
let key = b64::decode(key_b64)?;
- let plaintext = crypto::secretbox::decrypt(
+ Ok(crypto::secretbox::decrypt(
&ciphertext,
&crypto::Nonce::try_from_slice(&nonce)?,
&crypto::Key::try_from_slice(&key)?,
- )?;
- Ok(b64::encode(&plaintext))
+ )?)
}
#[cfg(feature = "crypto-seal")]
@@ -81,14 +97,13 @@ pub fn crypto_box_seal_open(
sealed_b64: &str,
recipient_public_key_b64: &str,
recipient_secret_key_b64: &str,
-) -> Result<String, Error> {
+) -> Result<Vec<u8>, Error> {
let sealed = b64::decode(sealed_b64)?;
let pk = b64::decode(recipient_public_key_b64)?;
let sk = b64::decode(recipient_secret_key_b64)?;
- let opened = crypto::sealed::open(
+ Ok(crypto::sealed::open(
&sealed,
&crypto::PublicKey::try_from_slice(&pk)?,
&crypto::SecretKey::try_from_slice(&sk)?,
- )?;
- Ok(b64::encode(&opened))
+ )?)
}
diff --git a/rust/bindings/wasm/lib/src/crypto/file.rs b/rust/bindings/wasm/lib/src/crypto/file.rs
index 16bb34078e..c764e5dc7c 100644
--- a/rust/bindings/wasm/lib/src/crypto/file.rs
+++ b/rust/bindings/wasm/lib/src/crypto/file.rs
@@ -100,11 +100,10 @@ pub struct EncryptedBlob {
}
#[wasm_bindgen(js_name = cryptoEncryptBlob)]
-pub fn crypto_encrypt_blob(data_b64: &str, key_b64: &str) -> Result<EncryptedBlob, Error> {
- let data = b64::decode(data_b64)?;
+pub fn crypto_encrypt_blob(data: &[u8], key_b64: &str) -> Result<EncryptedBlob, Error> {
let key = b64::decode(key_b64)?;
- let out = crypto::blob::encrypt(&data, &crypto::Key::try_from_slice(&key)?)?;
+ let out = crypto::blob::encrypt(data, &crypto::Key::try_from_slice(&key)?)?;
Ok(EncryptedBlob {
encrypted_data: b64::encode(&out.encrypted_data),
decryption_header: b64::encode(out.decryption_header.as_bytes()),
@@ -116,17 +115,16 @@ pub fn crypto_decrypt_blob(
encrypted_data_b64: &str,
decryption_header_b64: &str,
key_b64: &str,
-) -> Result<String, Error> {
+) -> Result<Vec<u8>, Error> {
let ciphertext = b64::decode(encrypted_data_b64)?;
let header = b64::decode(decryption_header_b64)?;
let key = b64::decode(key_b64)?;
- let plaintext = crypto::blob::decrypt(
+ Ok(crypto::blob::decrypt(
&ciphertext,
&crypto::Header::try_from_slice(&header)?,
&crypto::Key::try_from_slice(&key)?,
- )?;
- Ok(b64::encode(&plaintext))
+ )?)
}
#[wasm_bindgen(js_name = cryptoDecryptBlobLegacy)]
@@ -134,23 +132,22 @@ pub fn crypto_decrypt_blob_legacy(
encrypted_data_b64: &str,
decryption_header_b64: &str,
key_b64: &str,
-) -> Result<String, Error> {
+) -> Result<Vec<u8>, Error> {
let ciphertext = b64::decode(encrypted_data_b64)?;
let header = b64::decode(decryption_header_b64)?;
let key = b64::decode(key_b64)?;
- let plaintext = crypto::blob::decrypt_legacy(
+ Ok(crypto::blob::decrypt_legacy(
&ciphertext,
&crypto::Header::try_from_slice(&header)?,
&crypto::Key::try_from_slice(&key)?,
- )?;
- Ok(b64::encode(&plaintext))
+ )?)
}
#[wasm_bindgen(getter_with_clone)]
pub struct EncryptedStreamResult {
#[wasm_bindgen(readonly, js_name = encryptedData)]
- pub encrypted_data: String,
+ pub encrypted_data: Vec<u8>,
#[wasm_bindgen(readonly, js_name = decryptionHeader)]
pub decryption_header: String,
#[wasm_bindgen(readonly, js_name = md5Hash)]
@@ -172,7 +169,7 @@ pub fn crypto_encrypt_stream_with_key(
let (encrypted, md5) = writer.finalize();
Ok(EncryptedStreamResult {
- encrypted_data: b64::encode(&encrypted),
+ encrypted_data: encrypted,
decryption_header: b64::encode(header.as_bytes()),
md5_hash: b64::encode(&md5),
})
diff --git a/web/apps/locker/src/services/remote-collections.ts b/web/apps/locker/src/services/remote-collections.ts
index 26d4a3b51d..58a7e57fed 100644
--- a/web/apps/locker/src/services/remote-collections.ts
+++ b/web/apps/locker/src/services/remote-collections.ts
@@ -1,7 +1,7 @@
import { ensureLocalUser } from "ente-accounts/services/user";
import { authenticatedRequestHeaders, ensureOk } from "ente-base/http";
import { apiURL } from "ente-base/origins";
-import { encryptBox, generateKey, stringToB64 } from "ente-locker-wasm";
+import { encryptBox, encryptBoxBytes, generateKey } from "ente-locker-wasm";
import { findCollectionByType, getCollectionRecord } from "./remote-cache";
import { decryptCollectionKey, fetchLockerData } from "./remote-read";
import { RemoteCollectionCreateResponseSchema } from "./remote-types";
@@ -35,8 +35,10 @@ export const createCollection = async (
): Promise<number> => {
const collectionKey = await generateKey();
const encryptedKey = await encryptBox(collectionKey, masterKey);
- const nameB64 = stringToB64(name);
- const encryptedName = await encryptBox(nameB64, collectionKey);
+ const encryptedName = await encryptBoxBytes(
+ new TextEncoder().encode(name),
+ collectionKey,
+ );
const res = await fetch(await apiURL("/collections"), {
method: "POST",
@@ -73,8 +75,10 @@ export const renameCollection = async (
}
const collectionKey = await decryptCollectionKey(collectionRecord);
- const nameB64 = stringToB64(newName);
- const encryptedName = await encryptBox(nameB64, collectionKey);
+ const encryptedName = await encryptBoxBytes(
+ new TextEncoder().encode(newName),
+ collectionKey,
+ );
const res = await fetch(await apiURL("/collections/rename"), {
method: "POST",
diff --git a/web/apps/locker/src/services/remote-read.ts b/web/apps/locker/src/services/remote-read.ts
index c7e1e886ee..c292193701 100644
--- a/web/apps/locker/src/services/remote-read.ts
+++ b/web/apps/locker/src/services/remote-read.ts
@@ -12,9 +12,8 @@ import {
decryptBox,
decryptBoxBytes,
decryptMetadataJSON,
- encryptBox,
+ encryptBoxBytes,
openCollectionKey,
- stringToB64,
} from "ente-locker-wasm";
import { z } from "zod";
import { ensureAuthenticatedSession } from "./authenticated-session";
@@ -331,8 +330,8 @@ const encryptCollectionPayload = async (
payload: LockerCollectionPayload,
collectionKey: string,
) => {
- const encryptedPayload = await encryptBox(
- stringToB64(JSON.stringify(payload)),
+ const encryptedPayload = await encryptBoxBytes(
+ new TextEncoder().encode(JSON.stringify(payload)),
collectionKey,
);
diff --git a/web/apps/locker/src/services/remote-uploads.ts b/web/apps/locker/src/services/remote-uploads.ts
index eeac883aec..26c5853228 100644
--- a/web/apps/locker/src/services/remote-uploads.ts
+++ b/web/apps/locker/src/services/remote-uploads.ts
@@ -6,13 +6,11 @@ import {
} from "ente-base/http";
import { apiURL } from "ente-base/origins";
import {
- b64ToBytes,
createStreamEncryptor,
encryptBlob,
encryptBox,
encryptFileStreamWithKey,
md5Base64,
- stringToB64,
} from "ente-locker-wasm";
import { z } from "zod";
import {
@@ -430,9 +428,8 @@ export const uploadLockerFileWithDeps = async <TCollectionRecord>(
BLACK_THUMBNAIL_B64,
fileKey,
);
- const encryptedThumbBytes = b64ToBytes(encryptedThumb.encryptedData);
const thumbObjectKey = await uploadSingleObject(
- encryptedThumbBytes,
+ encryptedThumb.encryptedData,
encryptedThumb.md5Hash,
);
@@ -454,14 +451,14 @@ export const uploadLockerFileWithDeps = async <TCollectionRecord>(
};
const metadataJSON = JSON.stringify(metadata);
const encryptedMetadata = await encryptBlob(
- stringToB64(metadataJSON),
+ new TextEncoder().encode(metadataJSON),
fileKey,
);
const pubMagicMetadata = { noThumb: true };
const pubMagicJSON = JSON.stringify(pubMagicMetadata);
const encryptedPubMagic = await encryptBlob(
- stringToB64(pubMagicJSON),
+ new TextEncoder().encode(pubMagicJSON),
fileKey,
);
@@ -482,7 +479,7 @@ export const uploadLockerFileWithDeps = async <TCollectionRecord>(
thumbnail: {
objectKey: thumbObjectKey,
decryptionHeader: encryptedThumb.decryptionHeader,
- size: encryptedThumbBytes.length,
+ size: encryptedThumb.encryptedData.length,
},
metadata: {
encryptedData: encryptedMetadata.encryptedData,
diff --git a/web/apps/locker/src/services/remote.ts b/web/apps/locker/src/services/remote.ts
index 298724b156..be9caf19e2 100644
--- a/web/apps/locker/src/services/remote.ts
+++ b/web/apps/locker/src/services/remote.ts
@@ -11,7 +11,6 @@ import {
generateKey,
openFileLinkSecret,
prepareFileLink,
- stringToB64,
} from "ente-locker-wasm";
import { z } from "zod";
import { ensureAuthenticatedSession } from "./authenticated-session";
@@ -221,7 +220,7 @@ export const createInfoItem = async (
};
const metadataJSON = JSON.stringify(metadata);
const encryptedMetadata = await encryptBlob(
- stringToB64(metadataJSON),
+ new TextEncoder().encode(metadataJSON),
fileKey,
);
@@ -230,7 +229,10 @@ export const createInfoItem = async (
noThumb: true,
};
const pubMMJSON = JSON.stringify(pubMagicMetadata);
- const encryptedPubMM = await encryptBlob(stringToB64(pubMMJSON), fileKey);
+ const encryptedPubMM = await encryptBlob(
+ new TextEncoder().encode(pubMMJSON),
+ fileKey,
+ );
const res = await fetch(await apiURL("/files/meta"), {
method: "POST",
@@ -318,8 +320,10 @@ const updateItemMetadata = async (
editedTime: Date.now(),
};
const pubMMJSON = JSON.stringify(pubMagicMetadata);
- const encryptedPubMM = await encryptBlob(stringToB64(pubMMJSON), fileKey);
-
+ const encryptedPubMM = await encryptBlob(
+ new TextEncoder().encode(pubMMJSON),
+ fileKey,
+ );
const version = fileRecord.pubMagicMetadata?.version ?? 1;
const res = await fetch(await apiURL("/files/public-magic-metadata"), {
diff --git a/web/apps/locker/tests/item-metadata.test.ts b/web/apps/locker/tests/item-metadata.test.ts
index b36855f575..a212226b5a 100644
--- a/web/apps/locker/tests/item-metadata.test.ts
+++ b/web/apps/locker/tests/item-metadata.test.ts
@@ -23,7 +23,6 @@ vi.mock("ente-locker-wasm", () => ({
decryptBox: () => "file-key",
decryptMetadataJSON,
encryptBlob,
- stringToB64: (value: string) => value,
}));
vi.mock("../src/services/authenticated-session", () => ({}));
vi.mock("../src/services/remote-read", () => ({
@@ -89,11 +88,13 @@ test.each(["file", "note"] as const)(
});
expect(encryptBlob).toHaveBeenCalledWith(
- expect.any(String),
+ expect.any(Uint8Array),
"file-key",
);
const metadata = JSON.parse(
- encryptBlob.mock.calls[0]![0] as string,
+ new TextDecoder().decode(
+ encryptBlob.mock.calls[0]![0] as Uint8Array,
+ ),
) as Record<string, unknown>;
expect(typeof metadata.editedTime).toBe("number");
expect(metadata).toEqual({
diff --git a/web/packages/contacts/wasm.test.ts b/web/packages/contacts/wasm.test.ts
index ddd424c666..c1cb8196ba 100644
--- a/web/packages/contacts/wasm.test.ts
+++ b/web/packages/contacts/wasm.test.ts
@@ -2,7 +2,7 @@ import * as legacy from "ente-legacy-wasm/authenticated";
import * as locker from "ente-locker-wasm";
import * as photos from "ente-photos-wasm";
import {
- boxSealOpen,
+ boxSealOpenBytes,
encryptBox,
generateKey,
generateKeyPair,
@@ -211,7 +211,7 @@ describe("Legacy", () => {
const masterKey = await generateKey();
const recoveryKey = await generateKey();
const recipient = await generateKeyPair();
- let sharedRecoveryKey: string | undefined;
+ let sharedRecoveryKey: Uint8Array | undefined;
mockFetch(async (request) => {
switch (new URL(request.url).pathname) {
case "/users/public-key":
@@ -224,7 +224,7 @@ describe("Legacy", () => {
};
expect(body.email).toBe("[email protected]");
expect(body.recoveryNoticeInDays).toBe(30);
- sharedRecoveryKey = await boxSealOpen(
+ sharedRecoveryKey = await boxSealOpenBytes(
body.encryptedKey,
recipient,
);
@@ -242,7 +242,9 @@ describe("Legacy", () => {
});
try {
await legacy.addContact(session, "[email protected]", 30);
- expect(sharedRecoveryKey).toBe(recoveryKey);
+ expect(sharedRecoveryKey).toStrictEqual(
+ new Uint8Array(Buffer.from(recoveryKey, "base64")),
+ );
} finally {
session.free();
}
@@ -289,16 +291,11 @@ const encryptedContact = async () => {
const wrappedRootKey = await encryptBox(rootKey, masterKey);
const wrappedContactKey = await encryptBox(contactKey, rootKey);
const data = await locker.encryptBlob(
- Buffer.from(
- JSON.stringify({ contactUserId: 42, name: "Zoë 🦋" }),
- ).toString("base64"),
+ Buffer.from(JSON.stringify({ contactUserId: 42, name: "Zoë 🦋" })),
contactKey,
);
const picture = Uint8Array.from({ length: 4096 }, (_, i) => i % 256);
- const encryptedPicture = await locker.encryptBlob(
- Buffer.from(picture).toString("base64"),
- contactKey,
- );
+ const encryptedPicture = await locker.encryptBlob(picture, contactKey);
const fixture = {
masterKey,
wrappedRootContactKey: {
diff --git a/web/packages/wasm/locker/index.ts b/web/packages/wasm/locker/index.ts
index 442c587c2d..9744d7e835 100644
--- a/web/packages/wasm/locker/index.ts
+++ b/web/packages/wasm/locker/index.ts
@@ -111,6 +111,12 @@ export const encryptBox = async (dataB64: string, keyB64: string) =>
nonce: box.nonce,
}));
+export const encryptBoxBytes = async (data: Uint8Array, keyB64: string) =>
+ readAndFree((await wasm()).cryptoEncryptBoxBytes(data, keyB64), (box) => ({
+ encryptedData: box.encryptedData,
+ nonce: box.nonce,
+ }));
+
export const decryptBox = async (
box: EncryptedBox,
key: Uint8Array | string,
@@ -124,11 +130,15 @@ export const decryptBox = async (
export const decryptBoxBytes = async (
box: EncryptedBox,
key: Uint8Array | string,
-): Promise<Uint8Array<ArrayBuffer>> =>
- fromB64String(await decryptBox(box, key));
+): Promise<Uint8Array> =>
+ (await wasm()).cryptoDecryptBoxBytes(
+ toB64String(box.encryptedData),
+ toB64String(box.nonce),
+ toB64String(key),
+ );
-export const encryptBlob = async (dataB64: string, keyB64: string) =>
- readAndFree((await wasm()).cryptoEncryptBlob(dataB64, keyB64), (blob) => ({
+export const encryptBlob = async (data: Uint8Array, keyB64: string) =>
+ readAndFree((await wasm()).cryptoEncryptBlob(data, keyB64), (blob) => ({
encryptedData: blob.encryptedData,
decryptionHeader: blob.decryptionHeader,
}));
@@ -141,9 +151,9 @@ export const decryptMetadataJSON = async (
const encryptedData = toB64String(blob.encryptedData);
const decryptionHeader = toB64String(blob.decryptionHeader);
const keyB64 = toB64String(key);
- let plaintextB64: string;
+ let plaintext: Uint8Array;
try {
- plaintextB64 = wasmModule.cryptoDecryptBlob(
+ plaintext = wasmModule.cryptoDecryptBlob(
encryptedData,
decryptionHeader,
keyB64,
@@ -152,13 +162,13 @@ export const decryptMetadataJSON = async (
if (!(error instanceof Error && error.name == "stream_truncated")) {
throw error;
}
- plaintextB64 = wasmModule.cryptoDecryptBlobLegacy(
+ plaintext = wasmModule.cryptoDecryptBlobLegacy(
encryptedData,
decryptionHeader,
keyB64,
);
}
- return JSON.parse(new TextDecoder().decode(fromB64String(plaintextB64)));
+ return JSON.parse(new TextDecoder().decode(plaintext));
};
export const boxSeal = async (
@@ -184,28 +194,16 @@ export const encryptFileStreamWithKey = async (
readAndFree(
(await wasm()).cryptoEncryptStreamWithKey(dataB64, keyB64),
(file) => ({
- encryptedData: file.encryptedData,
+ // wasm-bindgen copies returned bytes into a new ArrayBuffer.
+ encryptedData: file.encryptedData as Uint8Array<ArrayBuffer>,
decryptionHeader: file.decryptionHeader,
md5Hash: file.md5Hash,
}),
);
-export const stringToB64 = (value: string): string =>
- toB64String(new TextEncoder().encode(value));
-
-export const b64ToBytes = (value: string): Uint8Array<ArrayBuffer> =>
- fromB64String(value);
-
const toB64String = (value: Uint8Array | string): string => {
if (typeof value == "string") return value;
let binary = "";
for (const byte of value) binary += String.fromCharCode(byte);
return btoa(binary);
};
-
-const fromB64String = (value: string): Uint8Array<ArrayBuffer> => {
- const binary = atob(value);
- const bytes = new Uint8Array(binary.length);
- for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
- return bytes;
-};
diff --git a/web/packages/wasm/locker/tests/crypto.test.ts b/web/packages/wasm/locker/tests/crypto.test.ts
index 9697135616..bb41fcc5ec 100644
--- a/web/packages/wasm/locker/tests/crypto.test.ts
+++ b/web/packages/wasm/locker/tests/crypto.test.ts
@@ -1,11 +1,77 @@
+import { createHash } from "node:crypto";
import { expect, test } from "vitest";
import {
- b64ToBytes,
+ createStreamDecryptor,
createStreamEncryptor,
+ decryptBox,
+ decryptBoxBytes,
decryptMetadataJSON,
+ encryptBlob,
+ encryptBox,
+ encryptBoxBytes,
+ encryptFileStreamWithKey,
+ generateKey,
} from "../index";
import { cryptoDecryptBlob } from "../pkg/ente_locker_wasm.js";
+test.each([
+ new Uint8Array(),
+ Uint8Array.from({ length: 256 }, (_, i) => i).subarray(1, 255),
+])("byte boxes interoperate with base64 boxes (case %#)", async (plaintext) => {
+ const key = await generateKey();
+ const plaintextB64 = Buffer.from(plaintext).toString("base64");
+ const box = await encryptBoxBytes(plaintext, key);
+ expect(await decryptBox(box, key)).toBe(plaintextB64);
+ expect(
+ await decryptBoxBytes(await encryptBox(plaintextB64, key), key),
+ ).toStrictEqual(plaintext);
+});
+
+test("metadata stays base64 on the wire and decodes to Unicode JSON", async () => {
+ const metadata = { title: "Zoë 🦋", note: "\u0000\n" };
+ const plaintext = new TextEncoder().encode(JSON.stringify(metadata));
+ const key = await generateKey();
+ const blob = await encryptBlob(plaintext, key);
+ const decryptor = await createStreamDecryptor(blob.decryptionHeader, key);
+ try {
+ expect(
+ decryptor.decryptChunk(Buffer.from(blob.encryptedData, "base64")),
+ ).toStrictEqual(plaintext);
+ expect(decryptor.isFinalized()).toBe(true);
+ expect(await decryptMetadataJSON(blob, key)).toStrictEqual(metadata);
+ await expect(
+ decryptMetadataJSON(blob, await generateKey()),
+ ).rejects.toBeInstanceOf(Error);
+ } finally {
+ decryptor.free();
+ }
+});
+
+test("encrypted file bytes are uploadable with their MD5 and header", async () => {
+ const plaintext = Uint8Array.from({ length: 256 }, (_, i) => i);
+ const key = await generateKey();
+ const encrypted = await encryptFileStreamWithKey(
+ Buffer.from(plaintext).toString("base64"),
+ key,
+ );
+ expect(encrypted.encryptedData).toBeInstanceOf(Uint8Array);
+ expect(encrypted.md5Hash).toBe(
+ createHash("md5").update(encrypted.encryptedData).digest("base64"),
+ );
+ const decryptor = await createStreamDecryptor(
+ encrypted.decryptionHeader,
+ key,
+ );
+ try {
+ expect(decryptor.decryptChunk(encrypted.encryptedData)).toStrictEqual(
+ plaintext,
+ );
+ expect(decryptor.isFinalized()).toBe(true);
+ } finally {
+ decryptor.free();
+ }
+});
+
test("metadata wrapper reads legacy JSON after a stream_truncated error", async () => {
const metadata = { title: "Zoë 🦋" };
const encryptor = await createStreamEncryptor();
@@ -28,7 +94,7 @@ test("metadata wrapper reads legacy JSON after a stream_truncated error", async
expect(
await decryptMetadataJSON(
{ encryptedData, decryptionHeader },
- b64ToBytes(key),
+ Buffer.from(key, "base64"),
),
).toStrictEqual(metadata);
} finally {
diff --git a/web/packages/wasm/prelogin/index.ts b/web/packages/wasm/prelogin/index.ts
index e57ceedf0d..eee65afd51 100644
--- a/web/packages/wasm/prelogin/index.ts
+++ b/web/packages/wasm/prelogin/index.ts
@@ -102,22 +102,16 @@ export const decryptBox = async (
toB64String(key),
);
-export const boxSealOpen = async (
+export const boxSealOpenBytes = async (
encryptedData: string,
keyPair: KeyPair,
-): Promise<string> =>
+): Promise<Uint8Array> =>
(await wasm()).cryptoBoxSealOpen(
encryptedData,
keyPair.publicKey,
keyPair.privateKey,
);
-export const boxSealOpenBytes = async (
- encryptedData: string,
- keyPair: KeyPair,
-): Promise<Uint8Array<ArrayBuffer>> =>
- fromB64String(await boxSealOpen(encryptedData, keyPair));
-
const derivedKeyValue = (key: DerivedKey): DerivedKey => ({
key: key.key,
salt: key.salt,
@@ -131,10 +125,3 @@ const toB64String = (value: Uint8Array | string): string => {
for (const byte of value) binary += String.fromCharCode(byte);
return btoa(binary);
};
-
-const fromB64String = (value: string): Uint8Array<ArrayBuffer> => {
- const binary = atob(value);
- const bytes = new Uint8Array(binary.length);
- for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
- return bytes;
-};
diff --git a/web/packages/wasm/prelogin/tests/crypto.test.ts b/web/packages/wasm/prelogin/tests/crypto.test.ts
new file mode 100644
index 0000000000..563cb56946
--- /dev/null
+++ b/web/packages/wasm/prelogin/tests/crypto.test.ts
@@ -0,0 +1,13 @@
+import { expect, test } from "vitest";
+import { boxSealOpenBytes } from "../index";
+
+test("opens a libsodium sealed token as bytes", async () => {
+ const token = await boxSealOpenBytes(
+ "jVHae52Eixf5JkF0B0jZYR0U/KQ8ckCM631dw253O0bPMmpGHRPieCG/KRKk075x4STFEptJDw==",
+ {
+ publicKey: "W/Vcc7guviK+gPNDBmevVw+uJVamQV5rMNQGUwCqlH0=",
+ privateKey: "UEatwduoOIZ7K7v90MNCPli1eXC1JnqQ9XlgkkqH8ZY=",
+ },
+ );
+ expect(token).toStrictEqual(new Uint8Array([0, 1, 127, 128, 254, 255, 16]));
+});