@protontech/drive-sdk 0.0.10

package/dist/crypto/driveCrypto.js

@@ -0,0 +1,364 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayToHexString = exports.DriveCrypto = void 0;
+exports.uint8ArrayToUtf8 = uint8ArrayToUtf8;
+const utils_1 = require("./utils");
+// TODO: Switch to CryptoProxy module once available.
+const hmac_1 = require("./hmac");
+var SIGNING_CONTEXTS;
+(function (SIGNING_CONTEXTS) {
+    SIGNING_CONTEXTS["SHARING_INVITER"] = "drive.share-member.inviter";
+    SIGNING_CONTEXTS["SHARING_INVITER_EXTERNAL_INVITATION"] = "drive.share-member.external-invitation";
+    SIGNING_CONTEXTS["SHARING_MEMBER"] = "drive.share-member.member";
+})(SIGNING_CONTEXTS || (SIGNING_CONTEXTS = {}));
+/**
+ * Drive crypto layer to provide general operations for Drive crypto.
+ *
+ * This layer focuses on providing general Drive crypto functions. Only
+ * high-level functions that are required on multiple places should be
+ * peresent. E.g., no specific implementation how keys are encrypted,
+ * but we do share same key generation across shares and nodes modules,
+ * for example, which we can generelise here and in each module just
+ * call with specific arguments.
+ */
+class DriveCrypto {
+    openPGPCrypto;
+    srpModule;
+    constructor(openPGPCrypto, srpModule) {
+        this.openPGPCrypto = openPGPCrypto;
+        this.srpModule = srpModule;
+        this.openPGPCrypto = openPGPCrypto;
+        this.srpModule = srpModule;
+    }
+    /**
+     * It generates passphrase and key that is encrypted with the
+     * generated passphrase.
+     *
+     * `encrpytionKeys` are used to generate session key, which is
+     * also used to encrypt the passphrase. The encrypted passphrase
+     * is signed with `signingKey`.
+     *
+     * @returns Object with:
+     *  - encrypted (armored) data (key, passphrase and passphrase
+     *    signature) for sending to the server
+     *  - decrypted data (key, sessionKey) for crypto usage
+     */
+    async generateKey(encryptionKeys, signingKey) {
+        const passphrase = this.openPGPCrypto.generatePassphrase();
+        const [{ privateKey, armoredKey }, passphraseSessionKey] = await Promise.all([
+            this.openPGPCrypto.generateKey(passphrase),
+            this.openPGPCrypto.generateSessionKey(encryptionKeys),
+        ]);
+        const { armoredPassphrase, armoredPassphraseSignature } = await this.encryptPassphrase(passphrase, passphraseSessionKey, encryptionKeys, signingKey);
+        return {
+            encrypted: {
+                armoredKey,
+                armoredPassphrase,
+                armoredPassphraseSignature,
+            },
+            decrypted: {
+                passphrase,
+                key: privateKey,
+                passphraseSessionKey,
+            },
+        };
+    }
+    ;
+    /**
+     * It generates content key from node key for encrypting file blocks.
+     *
+     * @param encryptionKey - Its own node key.
+     * @returns Object with serialised key packet and decrypted session key.
+     */
+    async generateContentKey(encryptionKey) {
+        const contentKeyPacketSessionKey = await this.openPGPCrypto.generateSessionKey([encryptionKey]);
+        const { signature: armoredContentKeyPacketSignature } = await this.openPGPCrypto.signArmored(contentKeyPacketSessionKey.data, [encryptionKey]);
+        const { keyPacket } = await this.openPGPCrypto.encryptSessionKey(contentKeyPacketSessionKey, [encryptionKey]);
+        return {
+            encrypted: {
+                base64ContentKeyPacket: (0, utils_1.uint8ArrayToBase64String)(keyPacket),
+                armoredContentKeyPacketSignature,
+            },
+            decrypted: {
+                contentKeyPacketSessionKey,
+            }
+        };
+    }
+    /**
+     * It encrypts passphrase with provided session and encryption keys.
+     * This should be used only for re-encrypting the passphrase with
+     * different key (e.g., moving the node to different parent).
+     *
+     * @returns Object with armored passphrase and passphrase signature.
+     */
+    async encryptPassphrase(passphrase, sessionKey, encryptionKeys, signingKey) {
+        const { armoredData: armoredPassphrase, armoredSignature: armoredPassphraseSignature } = await this.openPGPCrypto.encryptAndSignDetachedArmored(new TextEncoder().encode(passphrase), sessionKey, encryptionKeys, signingKey);
+        return {
+            armoredPassphrase,
+            armoredPassphraseSignature,
+        };
+    }
+    /**
+     * It decrypts key generated via `generateKey`.
+     *
+     * Armored data are passed from the server. `decryptionKeys` are used
+     * to decrypt the session key from the `armoredPassphrase`. Then the
+     * session key is used with `verificationKeys` to decrypt and verify
+     * the passphrase. Finally, the armored key is decrypted.
+     *
+     * Note: The function doesn't throw in case of verification issue.
+     * You have to read `verified` result and act based on that.
+     *
+     * @returns key and sessionKey for crypto usage, and verification status
+     */
+    async decryptKey(armoredKey, armoredPassphrase, armoredPassphraseSignature, decryptionKeys, verificationKeys) {
+        const passphraseSessionKey = await this.decryptSessionKey(armoredPassphrase, decryptionKeys);
+        const { data: decryptedPassphrase, verified } = await this.openPGPCrypto.decryptArmoredAndVerifyDetached(armoredPassphrase, armoredPassphraseSignature, passphraseSessionKey, verificationKeys);
+        const passphrase = uint8ArrayToUtf8(decryptedPassphrase);
+        const key = await this.openPGPCrypto.decryptKey(armoredKey, passphrase);
+        return {
+            passphrase,
+            key,
+            passphraseSessionKey,
+            verified,
+        };
+    }
+    /**
+     * It encrypts session key with provided encryption key.
+     */
+    async encryptSessionKey(sessionKey, encryptionKey) {
+        const { keyPacket } = await this.openPGPCrypto.encryptSessionKey(sessionKey, [encryptionKey]);
+        return {
+            base64KeyPacket: (0, utils_1.uint8ArrayToBase64String)(keyPacket),
+        };
+    }
+    /**
+     * It encrypts password with provided address key that can be used to
+     * manage the public link, encrypts share passphrase session key using
+     * provided bcrypt passphrase and generates SRP verifier.
+     */
+    async encryptPublicLinkPasswordAndSessionKey(password, addressKey, bcryptPassphrase, sharePassphraseSessionKey) {
+        const [{ armoredData: armoredPassword }, { keyPacket }, srp] = await Promise.all([
+            this.openPGPCrypto.encryptArmored(new TextEncoder().encode(password), [addressKey]),
+            this.openPGPCrypto.encryptSessionKeyWithPassword(sharePassphraseSessionKey, bcryptPassphrase),
+            this.srpModule.getSrpVerifier(password),
+        ]);
+        return {
+            armoredPassword,
+            base64SharePassphraseKeyPacket: (0, utils_1.uint8ArrayToBase64String)(keyPacket),
+            srp,
+        };
+    }
+    /**
+     * It decrypts session key from armored data.
+     *
+     * `decryptionKeys` are used to decrypt the session key from the `armoredData`.
+     */
+    async decryptSessionKey(armoredData, decryptionKeys) {
+        const sessionKey = await this.openPGPCrypto.decryptArmoredSessionKey(armoredData, decryptionKeys);
+        return sessionKey;
+    }
+    async decryptAndVerifySessionKey(base64data, armoredSignature, decryptionKeys, verificationKeys) {
+        const data = (0, utils_1.base64StringToUint8Array)(base64data);
+        const sessionKey = await this.openPGPCrypto.decryptSessionKey(data, decryptionKeys);
+        let verified;
+        if (armoredSignature) {
+            const result = await this.openPGPCrypto.verify(sessionKey.data, armoredSignature, verificationKeys);
+            verified = result.verified;
+        }
+        return {
+            sessionKey,
+            verified,
+        };
+    }
+    /**
+     * It decrypts key similarly like `decryptKey`, but without signature
+     * verification. This is used for invitations.
+     */
+    async decryptUnsignedKey(armoredKey, armoredPassphrase, decryptionKeys) {
+        const { data: decryptedPassphrase } = await this.openPGPCrypto.decryptArmoredAndVerify(armoredPassphrase, decryptionKeys, []);
+        const passphrase = uint8ArrayToUtf8(decryptedPassphrase);
+        const key = await this.openPGPCrypto.decryptKey(armoredKey, passphrase);
+        return key;
+    }
+    /**
+     * It encrypts and armors signature with provided session and encryption keys.
+     */
+    async encryptSignature(signature, encryptionKey, sessionKey) {
+        const { armoredData: armoredSignature } = await this.openPGPCrypto.encryptArmored(signature, [encryptionKey], sessionKey);
+        return {
+            armoredSignature,
+        };
+    }
+    /**
+     * It generates random 32 bytes that are encrypted and signed with
+     * the provided key.
+     */
+    async generateHashKey(encryptionAndSigningKey) {
+        // Once all clients can use non-ascii bytes, switch to simple
+        // generating of random bytes without encoding it into base64:
+        //const passphrase crypto.getRandomValues(new Uint8Array(32));
+        const passphrase = this.openPGPCrypto.generatePassphrase();
+        const hashKey = new TextEncoder().encode(passphrase);
+        const { armoredData: armoredHashKey } = await this.openPGPCrypto.encryptAndSignArmored(hashKey, undefined, [encryptionAndSigningKey], encryptionAndSigningKey);
+        return {
+            armoredHashKey,
+            hashKey,
+        };
+    }
+    async generateLookupHash(newName, parentHashKey) {
+        const key = await (0, hmac_1.importHmacKey)(parentHashKey);
+        const signature = await (0, hmac_1.computeHmacSignature)(key, new TextEncoder().encode(newName));
+        return (0, exports.arrayToHexString)(signature);
+    }
+    /**
+     * It converts node name into bytes array and encrypts and signs
+     * with provided keys.
+     *
+     * The function accepts either encryption or session key. Use encryption
+     * key if you want to encrypt the name for the new node. Use session key
+     * if you want to encrypt the new name for the existing node.
+     */
+    async encryptNodeName(nodeName, sessionKey, encryptionKey, signingKey) {
+        if (!sessionKey && !encryptionKey) {
+            throw new Error('Neither session nor encryption key provided for encrypting node name');
+        }
+        const { armoredData: armoredNodeName } = await this.openPGPCrypto.encryptAndSignArmored(new TextEncoder().encode(nodeName), sessionKey, encryptionKey ? [encryptionKey] : [], signingKey);
+        return {
+            armoredNodeName,
+        };
+    }
+    /**
+     * It decrypts armored node name and verifies embeded signature.
+     *
+     * Note: The function doesn't throw in case of verification issue.
+     * You have to read `verified` result and act based on that.
+     */
+    async decryptNodeName(armoredNodeName, decryptionKey, verificationKeys) {
+        const { data: name, verified } = await this.openPGPCrypto.decryptArmoredAndVerify(armoredNodeName, [decryptionKey], verificationKeys);
+        return {
+            name: uint8ArrayToUtf8(name),
+            verified,
+        };
+    }
+    /**
+     * It decrypts armored node hash key and verifies embeded signature.
+     *
+     * Note: The function doesn't throw in case of verification issue.
+     * You have to read `verified` result and act based on that.
+     */
+    async decryptNodeHashKey(armoredHashKey, decryptionAndVerificationKey, extraVerificationKeys) {
+        // In the past, we had misunderstanding what key is used to sign hash
+        // key. Originally, it meant to be the node key, which web used for all
+        // nodes besides the root one, where address key was used instead.
+        // Similarly, iOS or Android used address key for all nodes. Latest
+        // versions should use node key in all cases, but we accept also
+        // address key. Its still signed with a valid key.
+        const { data: hashKey, verified } = await this.openPGPCrypto.decryptArmoredAndVerify(armoredHashKey, [decryptionAndVerificationKey], [decryptionAndVerificationKey, ...extraVerificationKeys]);
+        return {
+            hashKey,
+            verified,
+        };
+    }
+    async encryptExtendedAttributes(extendedAttributes, encryptionKey, signingKey) {
+        const { armoredData: armoredExtendedAttributes } = await this.openPGPCrypto.encryptAndSignArmored(new TextEncoder().encode(extendedAttributes), undefined, [encryptionKey], signingKey);
+        return {
+            armoredExtendedAttributes,
+        };
+    }
+    async decryptExtendedAttributes(armoreExtendedAttributes, decryptionKey, verificationKeys) {
+        const { data: decryptedExtendedAttributes, verified } = await this.openPGPCrypto.decryptArmoredAndVerify(armoreExtendedAttributes, [decryptionKey], verificationKeys);
+        return {
+            extendedAttributes: uint8ArrayToUtf8(decryptedExtendedAttributes),
+            verified,
+        };
+    }
+    async encryptInvitation(shareSessionKey, encryptionKey, signingKey) {
+        const { keyPacket } = await this.openPGPCrypto.encryptSessionKey(shareSessionKey, encryptionKey);
+        const { signature: keyPacketSignature } = await this.openPGPCrypto.sign(keyPacket, signingKey, SIGNING_CONTEXTS.SHARING_INVITER);
+        return {
+            base64KeyPacket: (0, utils_1.uint8ArrayToBase64String)(keyPacket),
+            base64KeyPacketSignature: (0, utils_1.uint8ArrayToBase64String)(keyPacketSignature),
+        };
+    }
+    async acceptInvitation(base64KeyPacket, signingKey) {
+        const sessionKey = await this.decryptSessionKey(base64KeyPacket, signingKey);
+        const { signature } = await this.openPGPCrypto.sign(sessionKey.data, signingKey, SIGNING_CONTEXTS.SHARING_MEMBER);
+        return {
+            base64SessionKeySignature: (0, utils_1.uint8ArrayToBase64String)(signature),
+        };
+    }
+    async encryptExternalInvitation(shareSessionKey, signingKey, inviteeEmail) {
+        const data = inviteeEmail.concat('|').concat((0, utils_1.uint8ArrayToBase64String)(shareSessionKey.data));
+        const { signature: externalInviationSignature } = await this.openPGPCrypto.sign(new TextEncoder().encode(data), signingKey, SIGNING_CONTEXTS.SHARING_INVITER_EXTERNAL_INVITATION);
+        return {
+            base64ExternalInvitationSignature: (0, utils_1.uint8ArrayToBase64String)(externalInviationSignature),
+        };
+    }
+    async encryptThumbnailBlock(thumbnailData, sessionKey, signingKey) {
+        const { encryptedData } = await this.openPGPCrypto.encryptAndSign(thumbnailData, sessionKey, [], // Thumbnails use the session key so we do not send encryption key.
+        signingKey);
+        return {
+            encryptedData,
+        };
+    }
+    async decryptThumbnailBlock(encryptedThumbnail, sessionKey, verificationKeys) {
+        const { data: decryptedThumbnail, verified } = await this.openPGPCrypto.decryptAndVerify(encryptedThumbnail, sessionKey, verificationKeys);
+        return {
+            decryptedThumbnail,
+            verified,
+        };
+    }
+    async encryptBlock(blockData, encryptionKey, sessionKey, signingKey) {
+        const { encryptedData, signature } = await this.openPGPCrypto.encryptAndSignDetached(blockData, sessionKey, [], // Blocks use the session key so we do not send encryption key.
+        signingKey);
+        const { armoredSignature } = await this.encryptSignature(signature, encryptionKey, sessionKey);
+        return {
+            encryptedData,
+            armoredSignature,
+        };
+    }
+    async decryptBlock(encryptedBlock, armoredSignature, decryptionKey, sessionKey, verificationKeys) {
+        const signature = armoredSignature ? await this.openPGPCrypto.decryptArmored(armoredSignature, [decryptionKey]) : undefined;
+        const { data: decryptedBlock, verified } = await this.openPGPCrypto.decryptAndVerifyDetached(encryptedBlock, signature, sessionKey, verificationKeys);
+        return {
+            decryptedBlock,
+            verified,
+        };
+    }
+    async signManifest(manifest, signingKey) {
+        const { signature: armoredManifestSignature } = await this.openPGPCrypto.signArmored(manifest, signingKey);
+        return {
+            armoredManifestSignature,
+        };
+    }
+    async verifyManifest(manifest, armoredSignature, verificationKeys) {
+        const { verified } = await this.openPGPCrypto.verify(manifest, armoredSignature, verificationKeys);
+        return {
+            verified,
+        };
+    }
+    async decryptShareUrlPassword(armoredPassword, decryptionKeys) {
+        const password = await this.openPGPCrypto.decryptArmored(armoredPassword, decryptionKeys);
+        return uint8ArrayToUtf8(password);
+    }
+}
+exports.DriveCrypto = DriveCrypto;
+function uint8ArrayToUtf8(input) {
+    return new TextDecoder('utf-8', { fatal: true }).decode(input);
+}
+/**
+ * Convert an array of 8-bit integers to a hex string
+ * @param bytes - Array of 8-bit integers to convert
+ * @returns Hexadecimal representation of the array
+ */
+const arrayToHexString = (bytes) => {
+    const hexAlphabet = '0123456789abcdef';
+    let s = '';
+    bytes.forEach((v) => {
+        s += hexAlphabet[v >> 4] + hexAlphabet[v & 15];
+    });
+    return s;
+};
+exports.arrayToHexString = arrayToHexString;
+//# sourceMappingURL=driveCrypto.js.map

package/dist/crypto/driveCrypto.js.map

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

package/dist/crypto/driveCrypto.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/crypto/driveCrypto.test.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const driveCrypto_1 = require("./driveCrypto");
+describe("uint8ArrayToUtf8", () => {
+    it("should convert a Uint8Array to a UTF-8 string", () => {
+        const input = new Uint8Array([72, 101, 108, 108, 111]);
+        const expectedOutput = "Hello";
+        const result = (0, driveCrypto_1.uint8ArrayToUtf8)(input);
+        expect(result).toBe(expectedOutput);
+    });
+    it("should handle an empty Uint8Array", () => {
+        const input = new Uint8Array([]);
+        const expectedOutput = "";
+        const result = (0, driveCrypto_1.uint8ArrayToUtf8)(input);
+        expect(result).toBe(expectedOutput);
+    });
+    it("should throw if input is invalid", () => {
+        const input = new Uint8Array([887987979887897989]);
+        expect(() => (0, driveCrypto_1.uint8ArrayToUtf8)(input)).toThrow("The encoded data was not valid for encoding utf-8");
+    });
+});
+describe("arrayToHexString", () => {
+    it("should convert a Uint8Array to a hex string", () => {
+        const input = new Uint8Array([0, 255, 16, 32]);
+        const expectedOutput = "00ff1020";
+        const result = (0, driveCrypto_1.arrayToHexString)(input);
+        expect(result).toBe(expectedOutput);
+    });
+    it("should handle an empty Uint8Array", () => {
+        const input = new Uint8Array([]);
+        const expectedOutput = "";
+        const result = (0, driveCrypto_1.arrayToHexString)(input);
+        expect(result).toBe(expectedOutput);
+    });
+    it("should handle a Uint8Array with one element", () => {
+        const input = new Uint8Array([1]);
+        const expectedOutput = "01";
+        const result = (0, driveCrypto_1.arrayToHexString)(input);
+        expect(result).toBe(expectedOutput);
+    });
+});
+//# sourceMappingURL=driveCrypto.test.js.map

package/dist/crypto/driveCrypto.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"driveCrypto.test.js","sourceRoot":"","sources":["../../src/crypto/driveCrypto.test.ts"],"names":[],"mappings":";;AAAA,+CAAmE;AAEnE,QAAQ,CAAC,kBAAkB,EAAE,GAAG,EAAE;IAC9B,EAAE,CAAC,+CAA+C,EAAE,GAAG,EAAE;QACrD,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;QACvD,MAAM,cAAc,GAAG,OAAO,CAAC;QAC/B,MAAM,MAAM,GAAG,IAAA,8BAAgB,EAAC,KAAK,CAAC,CAAC;QACvC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mCAAmC,EAAE,GAAG,EAAE;QACzC,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;QACjC,MAAM,cAAc,GAAG,EAAE,CAAC;QAC1B,MAAM,MAAM,GAAG,IAAA,8BAAgB,EAAC,KAAK,CAAC,CAAC;QACvC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE;QACxC,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC;QACnD,MAAM,CAAC,GAAG,EAAE,CAAC,IAAA,8BAAgB,EAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,mDAAmD,CAAC,CAAC;IACvG,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,kBAAkB,EAAE,GAAG,EAAE;IAC9B,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;QACnD,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;QAC/C,MAAM,cAAc,GAAG,UAAU,CAAC;QAClC,MAAM,MAAM,GAAG,IAAA,8BAAgB,EAAC,KAAK,CAAC,CAAC;QACvC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mCAAmC,EAAE,GAAG,EAAE;QACzC,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;QACjC,MAAM,cAAc,GAAG,EAAE,CAAC;QAC1B,MAAM,MAAM,GAAG,IAAA,8BAAgB,EAAC,KAAK,CAAC,CAAC;QACvC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6CAA6C,EAAE,GAAG,EAAE;QACnD,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAClC,MAAM,cAAc,GAAG,IAAI,CAAC;QAC5B,MAAM,MAAM,GAAG,IAAA,8BAAgB,EAAC,KAAK,CAAC,CAAC;QACvC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACxC,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC"}

package/dist/crypto/hmac.d.ts

@@ -0,0 +1,22 @@
+export type HmacCryptoKey = CryptoKey;
+type HmacKeyUsage = 'sign' | 'verify';
+/**
+ * Import an HMAC-SHA256 key in order to use it with `signData` and `verifyData`.
+ */
+export declare const importHmacKey: (key: Uint8Array, keyUsage?: HmacKeyUsage[]) => Promise<HmacCryptoKey>;
+/**
+ * Sign data using HMAC-SHA256
+ * @param key - WebCrypto secret key for signing
+ * @param data - data to sign
+ * @param additionalData - additional data to authenticate
+ */
+export declare const computeHmacSignature: (key: HmacCryptoKey, data: Uint8Array) => Promise<Uint8Array>;
+/**
+ * Verify data using HMAC-SHA256
+ * @param key - WebCrypto secret key for verification
+ * @param signature - signature over data
+ * @param data - data to verify
+ * @param additionalData - additional data to authenticate
+ */
+export declare const verifyData: (key: HmacCryptoKey, signature: Uint8Array, data: Uint8Array) => Promise<boolean>;
+export {};

package/dist/crypto/hmac.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyData = exports.computeHmacSignature = exports.importHmacKey = void 0;
+const HASH_ALGORITHM = 'SHA-256';
+const KEY_LENGTH_BYTES = 32;
+/**
+ * Import an HMAC-SHA256 key in order to use it with `signData` and `verifyData`.
+ */
+const importHmacKey = async (key, keyUsage = ['sign', 'verify']) => {
+    // From https://datatracker.ietf.org/doc/html/rfc2104:
+    // The key for HMAC can be of any length (keys longer than B bytes are first hashed using H).
+    // However, less than L bytes (L = 32 bytes for SHA-256) is strongly discouraged as it would
+    // decrease the security strength of the function.  Keys longer than L bytes are acceptable
+    // but the extra length would not significantly increase the function strength.
+    // (A longer key may be advisable if the randomness of the key is considered weak.)
+    if (key.length < KEY_LENGTH_BYTES) {
+        throw new Error('Unexpected HMAC key size: key is too short');
+    }
+    return crypto.subtle.importKey('raw', key, { name: 'HMAC', hash: HASH_ALGORITHM }, false, keyUsage);
+};
+exports.importHmacKey = importHmacKey;
+/**
+ * Sign data using HMAC-SHA256
+ * @param key - WebCrypto secret key for signing
+ * @param data - data to sign
+ * @param additionalData - additional data to authenticate
+ */
+const computeHmacSignature = async (key, data) => {
+    const signatureBuffer = await crypto.subtle.sign({ name: 'HMAC', hash: HASH_ALGORITHM }, key, data);
+    return new Uint8Array(signatureBuffer);
+};
+exports.computeHmacSignature = computeHmacSignature;
+/**
+ * Verify data using HMAC-SHA256
+ * @param key - WebCrypto secret key for verification
+ * @param signature - signature over data
+ * @param data - data to verify
+ * @param additionalData - additional data to authenticate
+ */
+const verifyData = async (key, signature, data) => {
+    return crypto.subtle.verify({ name: 'HMAC', hash: HASH_ALGORITHM }, key, signature, data);
+};
+exports.verifyData = verifyData;
+//# sourceMappingURL=hmac.js.map

package/dist/crypto/hmac.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.js","sourceRoot":"","sources":["../../src/crypto/hmac.ts"],"names":[],"mappings":";;;AAAA,MAAM,cAAc,GAAG,SAAS,CAAC;AACjC,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAK5B;;GAEG;AACI,MAAM,aAAa,GAAG,KAAK,EAC9B,GAAe,EACf,WAA2B,CAAC,MAAM,EAAE,QAAQ,CAAC,EACvB,EAAE;IACxB,sDAAsD;IACtD,6FAA6F;IAC7F,4FAA4F;IAC5F,2FAA2F;IAC3F,+EAA+E;IAC/E,mFAAmF;IACnF,IAAI,GAAG,CAAC,MAAM,GAAG,gBAAgB,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;AACxG,CAAC,CAAC;AAdW,QAAA,aAAa,iBAcxB;AAEF;;;;;GAKG;AACI,MAAM,oBAAoB,GAAG,KAAK,EAAE,GAAkB,EAAE,IAAgB,EAAE,EAAE;IAC/E,MAAM,eAAe,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;IACpG,OAAO,IAAI,UAAU,CAAC,eAAe,CAAC,CAAC;AAC3C,CAAC,CAAC;AAHW,QAAA,oBAAoB,wBAG/B;AAEF;;;;;;GAMG;AACI,MAAM,UAAU,GAAG,KAAK,EAAE,GAAkB,EAAE,SAAqB,EAAE,IAAgB,EAAE,EAAE;IAC5F,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;AAC9F,CAAC,CAAC;AAFW,QAAA,UAAU,cAErB"}

package/dist/crypto/index.d.ts

@@ -0,0 +1,6 @@
+export type { OpenPGPCrypto, PrivateKey, PublicKey, SessionKey, SRPModule, SRPVerifier } from './interface';
+export { VERIFICATION_STATUS } from './interface';
+export { DriveCrypto } from './driveCrypto';
+export type { OpenPGPCryptoProxy } from './openPGPCrypto';
+export { OpenPGPCryptoWithCryptoProxy } from './openPGPCrypto';
+export { uint8ArrayToBase64String, base64StringToUint8Array } from './utils';

package/dist/crypto/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64StringToUint8Array = exports.uint8ArrayToBase64String = exports.OpenPGPCryptoWithCryptoProxy = exports.DriveCrypto = exports.VERIFICATION_STATUS = void 0;
+var interface_1 = require("./interface");
+Object.defineProperty(exports, "VERIFICATION_STATUS", { enumerable: true, get: function () { return interface_1.VERIFICATION_STATUS; } });
+var driveCrypto_1 = require("./driveCrypto");
+Object.defineProperty(exports, "DriveCrypto", { enumerable: true, get: function () { return driveCrypto_1.DriveCrypto; } });
+var openPGPCrypto_1 = require("./openPGPCrypto");
+Object.defineProperty(exports, "OpenPGPCryptoWithCryptoProxy", { enumerable: true, get: function () { return openPGPCrypto_1.OpenPGPCryptoWithCryptoProxy; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "uint8ArrayToBase64String", { enumerable: true, get: function () { return utils_1.uint8ArrayToBase64String; } });
+Object.defineProperty(exports, "base64StringToUint8Array", { enumerable: true, get: function () { return utils_1.base64StringToUint8Array; } });
+//# sourceMappingURL=index.js.map

package/dist/crypto/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/crypto/index.ts"],"names":[],"mappings":";;;AACA,yCAAkD;AAAzC,gHAAA,mBAAmB,OAAA;AAC5B,6CAA4C;AAAnC,0GAAA,WAAW,OAAA;AAEpB,iDAA+D;AAAtD,6HAAA,4BAA4B,OAAA;AACrC,iCAA6E;AAApE,iHAAA,wBAAwB,OAAA;AAAE,iHAAA,wBAAwB,OAAA"}

package/dist/crypto/interface.d.ts

@@ -0,0 +1,125 @@
+export interface PublicKey {
+    readonly _idx: any;
+    readonly _keyContentHash: [string, string];
+    getVersion(): number;
+    getFingerprint(): string;
+    getSHA256Fingerprints(): string[];
+    getKeyID(): any;
+    getKeyIDs(): any[];
+    getAlgorithmInfo(): any;
+    getCreationTime(): Date;
+    isPrivate: any;
+    isPrivateKeyV4: any;
+    isPrivateKeyV6: any;
+    getExpirationTime(): Date | number | null;
+    getUserIDs(): string[];
+    isWeak(): boolean;
+    equals(otherKey: any, ignoreOtherCerts?: boolean): boolean;
+    subkeys: {
+        getAlgorithmInfo(): any;
+        getKeyID(): any;
+    }[];
+}
+export interface PrivateKey extends PublicKey {
+    readonly _dummyType: 'private';
+}
+export interface SessionKey {
+    data: Uint8Array;
+    algorithm: any;
+    aeadAlgorithm?: any;
+}
+export declare enum VERIFICATION_STATUS {
+    NOT_SIGNED = 0,
+    SIGNED_AND_VALID = 1,
+    SIGNED_AND_INVALID = 2
+}
+export interface SRPModule {
+    getSrpVerifier: (password: string) => Promise<SRPVerifier>;
+}
+export type SRPVerifier = {
+    modulusId: string;
+    version: number;
+    salt: string;
+    verifier: string;
+};
+/**
+ * OpenPGP crypto layer to provide necessary PGP operations for Drive crypto.
+ *
+ * This layer focuses on providing general openPGP functions. Every operation
+ * should prefer binary input and output. Ideally, armoring should be done
+ * later in serialisation step, but for now, it is part of the interface to
+ * be somewhat compatible with current web app, and also be more efficient
+ * (current CryptoProxy can do encryption and armoring in one operation with
+ * less passing data between web workers). In the future, we want to separate
+ * this out of here more.
+ */
+export interface OpenPGPCrypto {
+    /**
+     * Generate a random passphrase.
+     *
+     * 32 random bytes are generated and encoded into a base64 string.
+     */
+    generatePassphrase: () => string;
+    generateSessionKey: (encryptionKeys: PrivateKey[]) => Promise<SessionKey>;
+    encryptSessionKey: (sessionKey: SessionKey, encryptionKeys: PublicKey | PublicKey[]) => Promise<{
+        keyPacket: Uint8Array;
+    }>;
+    encryptSessionKeyWithPassword: (sessionKey: SessionKey, password: string) => Promise<{
+        keyPacket: Uint8Array;
+    }>;
+    /**
+     * Generate a new key pair locked by a passphrase.
+     *
+     * The key pair is generated using the Curve25519 algorithm.
+     */
+    generateKey: (passphrase: string) => Promise<{
+        privateKey: PrivateKey;
+        armoredKey: string;
+    }>;
+    encryptArmored: (data: Uint8Array, encryptionKeys: PrivateKey[], sessionKey?: SessionKey) => Promise<{
+        armoredData: string;
+    }>;
+    encryptAndSign: (data: Uint8Array, sessionKey: SessionKey, encryptionKeys: PrivateKey[], signingKey: PrivateKey) => Promise<{
+        encryptedData: Uint8Array;
+    }>;
+    encryptAndSignArmored: (data: Uint8Array, sessionKey: SessionKey | undefined, encryptionKeys: PrivateKey[], signingKey: PrivateKey) => Promise<{
+        armoredData: string;
+    }>;
+    encryptAndSignDetached: (data: Uint8Array, sessionKey: SessionKey, encryptionKeys: PrivateKey[], signingKey: PrivateKey) => Promise<{
+        encryptedData: Uint8Array;
+        signature: Uint8Array;
+    }>;
+    encryptAndSignDetachedArmored: (data: Uint8Array, sessionKey: SessionKey, encryptionKeys: PrivateKey[], signingKey: PrivateKey) => Promise<{
+        armoredData: string;
+        armoredSignature: string;
+    }>;
+    sign: (data: Uint8Array, signingKey: PrivateKey, signatureContext: string) => Promise<{
+        signature: Uint8Array;
+    }>;
+    signArmored: (data: Uint8Array, signingKey: PrivateKey | PrivateKey[]) => Promise<{
+        signature: string;
+    }>;
+    verify: (data: Uint8Array, armoredSignature: string, verificationKeys: PublicKey | PublicKey[]) => Promise<{
+        verified: VERIFICATION_STATUS;
+    }>;
+    decryptSessionKey: (data: Uint8Array, decryptionKeys: PrivateKey | PrivateKey[]) => Promise<SessionKey>;
+    decryptArmoredSessionKey: (armoredData: string, decryptionKeys: PrivateKey | PrivateKey[]) => Promise<SessionKey>;
+    decryptKey: (armoredKey: string, passphrase: string) => Promise<PrivateKey>;
+    decryptAndVerify(data: Uint8Array, sessionKey: SessionKey, verificationKeys: PublicKey | PublicKey[]): Promise<{
+        data: Uint8Array;
+        verified: VERIFICATION_STATUS;
+    }>;
+    decryptAndVerifyDetached(data: Uint8Array, signature: Uint8Array | undefined, sessionKey: SessionKey, verificationKeys?: PublicKey | PublicKey[]): Promise<{
+        data: Uint8Array;
+        verified: VERIFICATION_STATUS;
+    }>;
+    decryptArmored(armoredData: string, decryptionKeys: PrivateKey | PrivateKey[]): Promise<Uint8Array>;
+    decryptArmoredAndVerify: (armoredData: string, decryptionKeys: PrivateKey | PrivateKey[], verificationKeys: PublicKey | PublicKey[]) => Promise<{
+        data: Uint8Array;
+        verified: VERIFICATION_STATUS;
+    }>;
+    decryptArmoredAndVerifyDetached: (armoredData: string, armoredSignature: string, sessionKey: SessionKey, verificationKeys: PublicKey | PublicKey[]) => Promise<{
+        data: Uint8Array;
+        verified: VERIFICATION_STATUS;
+    }>;
+}