@protontech/drive-sdk 0.0.13 → 0.1.1

package/src/crypto/interface.ts

@@ -48,24 +48,24 @@ export interface SessionKey {
 export enum VERIFICATION_STATUS {
     NOT_SIGNED = 0,
     SIGNED_AND_VALID = 1,
-    SIGNED_AND_INVALID = 2
+    SIGNED_AND_INVALID = 2,
 }
 
 export interface SRPModule {
-    getSrpVerifier: (password: string) => Promise<SRPVerifier>,
-    computeKeyPassword: (password: string, salt: string) => Promise<string>,
+    getSrpVerifier: (password: string) => Promise<SRPVerifier>;
+    computeKeyPassword: (password: string, salt: string) => Promise<string>;
 }
 
 export type SRPVerifier = {
-    modulusId: string,
-    version: number,
-    salt: string,
-    verifier: string,
-}
+    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
@@ -77,38 +77,44 @@ export type SRPVerifier = {
 export interface OpenPGPCrypto {
     /**
      * Generate a random passphrase.
-     * 
+     *
      * 32 random bytes are generated and encoded into a base64 string.
      */
-    generatePassphrase: () => string,
+    generatePassphrase: () => string;
 
-    generateSessionKey: (encryptionKeys: PrivateKey[]) => Promise<SessionKey>,
+    generateSessionKey: (encryptionKeys: PrivateKey[]) => Promise<SessionKey>;
 
-    encryptSessionKey: (sessionKey: SessionKey, encryptionKeys: PublicKey | PublicKey[]) => Promise<{
-        keyPacket: Uint8Array,
-    }>,
+    encryptSessionKey: (
+        sessionKey: SessionKey,
+        encryptionKeys: PublicKey | PublicKey[],
+    ) => Promise<{
+        keyPacket: Uint8Array;
+    }>;
 
-    encryptSessionKeyWithPassword: (sessionKey: SessionKey, password: string) => 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,
-    }>,
+        privateKey: PrivateKey;
+        armoredKey: string;
+    }>;
 
     encryptArmored: (
         data: Uint8Array,
         encryptionKeys: PrivateKey[],
         sessionKey?: SessionKey,
     ) => Promise<{
-        armoredData: string,
-    }>,
+        armoredData: string;
+    }>;
 
     encryptAndSign: (
         data: Uint8Array,
@@ -116,8 +122,8 @@ export interface OpenPGPCrypto {
         encryptionKeys: PrivateKey[],
         signingKey: PrivateKey,
     ) => Promise<{
-        encryptedData: Uint8Array,
-    }>,
+        encryptedData: Uint8Array;
+    }>;
 
     encryptAndSignArmored: (
         data: Uint8Array,
@@ -125,8 +131,8 @@ export interface OpenPGPCrypto {
         encryptionKeys: PrivateKey[],
         signingKey: PrivateKey,
     ) => Promise<{
-        armoredData: string,
-    }>,
+        armoredData: string;
+    }>;
 
     encryptAndSignDetached: (
         data: Uint8Array,
@@ -134,9 +140,9 @@ export interface OpenPGPCrypto {
         encryptionKeys: PrivateKey[],
         signingKey: PrivateKey,
     ) => Promise<{
-        encryptedData: Uint8Array,
-        signature: Uint8Array,
-    }>,
+        encryptedData: Uint8Array;
+        signature: Uint8Array;
+    }>;
 
     encryptAndSignDetachedArmored: (
         data: Uint8Array,
@@ -144,56 +150,47 @@ export interface OpenPGPCrypto {
         encryptionKeys: PrivateKey[],
         signingKey: PrivateKey,
     ) => Promise<{
-        armoredData: string,
-        armoredSignature: string,
-    }>,
+        armoredData: string;
+        armoredSignature: string;
+    }>;
 
     sign: (
         data: Uint8Array,
         signingKey: PrivateKey,
         signatureContext: string,
     ) => Promise<{
-        signature: Uint8Array,
-    }>,
+        signature: Uint8Array;
+    }>;
 
     signArmored: (
         data: Uint8Array,
         signingKey: PrivateKey | PrivateKey[],
     ) => Promise<{
-        signature: string,
-    }>,
+        signature: string;
+    }>;
 
     verify: (
         data: Uint8Array,
         armoredSignature: string,
         verificationKeys: PublicKey | PublicKey[],
     ) => Promise<{
-        verified: VERIFICATION_STATUS,
-    }>,
+        verified: VERIFICATION_STATUS;
+    }>;
 
-    decryptSessionKey: (
-        data: Uint8Array,
-        decryptionKeys: PrivateKey | PrivateKey[],
-    ) => Promise<SessionKey>,
+    decryptSessionKey: (data: Uint8Array, decryptionKeys: PrivateKey | PrivateKey[]) => Promise<SessionKey>;
 
-    decryptArmoredSessionKey: (
-        armoredData: string,
-        decryptionKeys: PrivateKey | PrivateKey[],
-    ) => Promise<SessionKey>,
+    decryptArmoredSessionKey: (armoredData: string, decryptionKeys: PrivateKey | PrivateKey[]) => Promise<SessionKey>;
 
-    decryptKey: (
-        armoredKey: string,
-        passphrase: string,
-    ) => Promise<PrivateKey>,
+    decryptKey: (armoredKey: string, passphrase: string) => Promise<PrivateKey>;
 
     decryptAndVerify(
         data: Uint8Array,
         sessionKey: SessionKey,
         verificationKeys: PublicKey | PublicKey[],
     ): Promise<{
-        data: Uint8Array,
-        verified: VERIFICATION_STATUS,
-    }>,
+        data: Uint8Array;
+        verified: VERIFICATION_STATUS;
+    }>;
 
     decryptAndVerifyDetached(
         data: Uint8Array,
@@ -201,23 +198,20 @@ export interface OpenPGPCrypto {
         sessionKey: SessionKey,
         verificationKeys?: PublicKey | PublicKey[],
     ): Promise<{
-        data: Uint8Array,
-        verified: VERIFICATION_STATUS,
-    }>,
+        data: Uint8Array;
+        verified: VERIFICATION_STATUS;
+    }>;
 
-    decryptArmored(
-        armoredData: string,
-        decryptionKeys: PrivateKey | PrivateKey[],
-    ): Promise<Uint8Array>,
+    decryptArmored(armoredData: string, decryptionKeys: PrivateKey | PrivateKey[]): Promise<Uint8Array>;
 
     decryptArmoredAndVerify: (
         armoredData: string,
         decryptionKeys: PrivateKey | PrivateKey[],
         verificationKeys: PublicKey | PublicKey[],
     ) => Promise<{
-        data: Uint8Array,
-        verified: VERIFICATION_STATUS,
-    }>,
+        data: Uint8Array;
+        verified: VERIFICATION_STATUS;
+    }>;
 
     decryptArmoredAndVerifyDetached: (
         armoredData: string,
@@ -225,12 +219,9 @@ export interface OpenPGPCrypto {
         sessionKey: SessionKey,
         verificationKeys: PublicKey | PublicKey[],
     ) => Promise<{
-        data: Uint8Array,
-        verified: VERIFICATION_STATUS,
-    }>,
+        data: Uint8Array;
+        verified: VERIFICATION_STATUS;
+    }>;
 
-    decryptArmoredWithPassword(
-        armoredData: string,
-        password: string,
-    ): Promise<Uint8Array>,
+    decryptArmoredWithPassword(armoredData: string, password: string): Promise<Uint8Array>;
 }

package/src/crypto/openPGPCrypto.ts

@@ -6,57 +6,63 @@ import { uint8ArrayToBase64String } from './utils';
  * clients/packages/crypto/lib/proxy/proxy.ts.
  */
 export interface OpenPGPCryptoProxy {
-    generateKey: (options: { userIDs: { name: string }[], type: 'ecc', curve: 'ed25519Legacy' }) => Promise<PrivateKey>,
-    exportPrivateKey: (options: { privateKey: PrivateKey, passphrase: string | null }) => Promise<string>,
-    importPrivateKey: (options: { armoredKey: string, passphrase: string | null }) => Promise<PrivateKey>,
-    generateSessionKey: (options: { recipientKeys: PrivateKey[] }) => Promise<SessionKey>,
-    encryptSessionKey: (options: SessionKey & { format: 'binary', encryptionKeys?: PublicKey | PublicKey[], passwords?: string[] }) => Promise<Uint8Array>,
-    decryptSessionKey: (options: { armoredMessage?: string, binaryMessage?: Uint8Array, decryptionKeys: PrivateKey | PrivateKey[] }) => Promise<SessionKey | undefined>,
+    generateKey: (options: { userIDs: { name: string }[]; type: 'ecc'; curve: 'ed25519Legacy' }) => Promise<PrivateKey>;
+    exportPrivateKey: (options: { privateKey: PrivateKey; passphrase: string | null }) => Promise<string>;
+    importPrivateKey: (options: { armoredKey: string; passphrase: string | null }) => Promise<PrivateKey>;
+    generateSessionKey: (options: { recipientKeys: PrivateKey[] }) => Promise<SessionKey>;
+    encryptSessionKey: (
+        options: SessionKey & { format: 'binary'; encryptionKeys?: PublicKey | PublicKey[]; passwords?: string[] },
+    ) => Promise<Uint8Array>;
+    decryptSessionKey: (options: {
+        armoredMessage?: string;
+        binaryMessage?: Uint8Array;
+        decryptionKeys: PrivateKey | PrivateKey[];
+    }) => Promise<SessionKey | undefined>;
     encryptMessage: (options: {
-        format?: 'armored' | 'binary',
-        binaryData: Uint8Array,
-        sessionKey?: SessionKey,
-        encryptionKeys: PrivateKey[],
-        signingKeys?: PrivateKey,
-        detached?: boolean,
+        format?: 'armored' | 'binary';
+        binaryData: Uint8Array;
+        sessionKey?: SessionKey;
+        encryptionKeys: PrivateKey[];
+        signingKeys?: PrivateKey;
+        detached?: boolean;
     }) => Promise<{
-        message: string | Uint8Array,
-        signature?: string | Uint8Array,
-    }>,
+        message: string | Uint8Array;
+        signature?: string | Uint8Array;
+    }>;
     decryptMessage: (options: {
-        format: 'utf8' | 'binary',
-        armoredMessage?: string,
-        binaryMessage?: Uint8Array,
-        armoredSignature?: string,
-        binarySignature?: Uint8Array,
-        sessionKeys?: SessionKey,
-        passwords?: string[],
-        decryptionKeys?: PrivateKey | PrivateKey[],
-        verificationKeys?: PublicKey | PublicKey[],
+        format: 'utf8' | 'binary';
+        armoredMessage?: string;
+        binaryMessage?: Uint8Array;
+        armoredSignature?: string;
+        binarySignature?: Uint8Array;
+        sessionKeys?: SessionKey;
+        passwords?: string[];
+        decryptionKeys?: PrivateKey | PrivateKey[];
+        verificationKeys?: PublicKey | PublicKey[];
     }) => Promise<{
-        data: Uint8Array | string,
+        data: Uint8Array | string;
         // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
         // Web clients are using newer pmcrypto, but CLI is using older version due to build issues with Bun.
-        verified?: VERIFICATION_STATUS,
-        verificationStatus?: VERIFICATION_STATUS,
-    }>,
+        verified?: VERIFICATION_STATUS;
+        verificationStatus?: VERIFICATION_STATUS;
+    }>;
     signMessage: (options: {
-        format: 'binary' | 'armored',
-        binaryData: Uint8Array,
-        signingKeys: PrivateKey | PrivateKey[],
-        detached: boolean,
-        signatureContext?: { critical: boolean, value: string },
-    }) => Promise<Uint8Array | string>,
+        format: 'binary' | 'armored';
+        binaryData: Uint8Array;
+        signingKeys: PrivateKey | PrivateKey[];
+        detached: boolean;
+        signatureContext?: { critical: boolean; value: string };
+    }) => Promise<Uint8Array | string>;
     verifyMessage: (options: {
-        binaryData: Uint8Array,
-        armoredSignature: string,
-        verificationKeys: PublicKey | PublicKey[],
+        binaryData: Uint8Array;
+        armoredSignature: string;
+        verificationKeys: PublicKey | PublicKey[];
     }) => Promise<{
         // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
         // Web clients are using newer pmcrypto, but CLI is using older version due to build issues with Bun.
-        verified?: VERIFICATION_STATUS,
-        verificationStatus?: VERIFICATION_STATUS,
-    }>,
+        verified?: VERIFICATION_STATUS;
+        verificationStatus?: VERIFICATION_STATUS;
+    }>;
 }
 
 /**
@@ -71,6 +77,8 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
 
     generatePassphrase(): string {
         const value = crypto.getRandomValues(new Uint8Array(32));
+        // TODO: Once all clients can use non-ascii bytes, switch to simple
+        // generating of random bytes without encoding it into base64.
         return uint8ArrayToBase64String(value);
     }
 
@@ -85,7 +93,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             encryptionKeys,
         });
         return {
-            keyPacket
+            keyPacket,
         };
     }
 
@@ -118,11 +126,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         };
     }
 
-    async encryptArmored(
-        data: Uint8Array,
-        encryptionKeys: PrivateKey[],
-        sessionKey?: SessionKey,
-    ) {
+    async encryptArmored(data: Uint8Array, encryptionKeys: PrivateKey[], sessionKey?: SessionKey) {
         const { message: armoredData } = await this.cryptoProxy.encryptMessage({
             binaryData: data,
             sessionKey,
@@ -130,7 +134,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         });
         return {
             armoredData: armoredData as string,
-        }
+        };
     }
 
     async encryptAndSign(
@@ -187,7 +191,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         return {
             encryptedData: encryptedData as Uint8Array,
             signature: signature as Uint8Array,
-        }
+        };
     }
 
     async encryptAndSignDetachedArmored(
@@ -206,14 +210,10 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         return {
             armoredData: armoredData as string,
             armoredSignature: armoredSignature as string,
-        }
+        };
     }
 
-    async sign(
-        data: Uint8Array,
-        signingKeys: PrivateKey | PrivateKey[],
-        signatureContext: string,
-    ) {
+    async sign(data: Uint8Array, signingKeys: PrivateKey | PrivateKey[], signatureContext: string) {
         const signature = await this.cryptoProxy.signMessage({
             binaryData: data,
             signingKeys,
@@ -226,10 +226,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         };
     }
 
-    async signArmored(
-        data: Uint8Array,
-        signingKeys: PrivateKey | PrivateKey[],
-    ) {
+    async signArmored(data: Uint8Array, signingKeys: PrivateKey | PrivateKey[]) {
         const signature = await this.cryptoProxy.signMessage({
             binaryData: data,
             signingKeys,
@@ -241,11 +238,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         };
     }
 
-    async verify(
-        data: Uint8Array,
-        armoredSignature: string,
-        verificationKeys: PublicKey | PublicKey[],
-    ) {
+    async verify(data: Uint8Array, armoredSignature: string, verificationKeys: PublicKey | PublicKey[]) {
         const { verified, verificationStatus } = await this.cryptoProxy.verifyMessage({
             binaryData: data,
             armoredSignature,
@@ -258,10 +251,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         };
     }
 
-    async decryptSessionKey(
-        data: Uint8Array,
-        decryptionKeys: PrivateKey | PrivateKey[],
-    ) {
+    async decryptSessionKey(data: Uint8Array, decryptionKeys: PrivateKey | PrivateKey[]) {
         const sessionKey = await this.cryptoProxy.decryptSessionKey({
             binaryMessage: data,
             decryptionKeys,
@@ -274,10 +264,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         return sessionKey;
     }
 
-    async decryptArmoredSessionKey(
-        armoredData: string,
-        decryptionKeys: PrivateKey | PrivateKey[],
-    ) {
+    async decryptArmoredSessionKey(armoredData: string, decryptionKeys: PrivateKey | PrivateKey[]) {
         const sessionKey = await this.cryptoProxy.decryptSessionKey({
             armoredMessage: armoredData,
             decryptionKeys,
@@ -290,10 +277,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         return sessionKey;
     }
 
-    async decryptKey(
-        armoredKey: string,
-        passphrase: string,
-    ) {
+    async decryptKey(armoredKey: string, passphrase: string) {
         const key = await this.cryptoProxy.importPrivateKey({
             armoredKey,
             passphrase,
@@ -301,12 +285,12 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         return key;
     }
 
-    async decryptAndVerify(
-        data: Uint8Array,
-        sessionKey: SessionKey,
-        verificationKeys: PublicKey[],
-    ) {
-        const { data: decryptedData, verified, verificationStatus } = await this.cryptoProxy.decryptMessage({
+    async decryptAndVerify(data: Uint8Array, sessionKey: SessionKey, verificationKeys: PublicKey[]) {
+        const {
+            data: decryptedData,
+            verified,
+            verificationStatus,
+        } = await this.cryptoProxy.decryptMessage({
             binaryMessage: data,
             sessionKeys: sessionKey,
             verificationKeys,
@@ -318,7 +302,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
             // Proper typing is too complex, it will be removed to support only newer pmcrypto.
             verified: verified || verificationStatus!,
-        }
+        };
     }
 
     async decryptAndVerifyDetached(
@@ -327,7 +311,11 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
         sessionKey: SessionKey,
         verificationKeys?: PublicKey[],
     ) {
-        const { data: decryptedData, verified, verificationStatus } = await this.cryptoProxy.decryptMessage({
+        const {
+            data: decryptedData,
+            verified,
+            verificationStatus,
+        } = await this.cryptoProxy.decryptMessage({
             binaryMessage: data,
             binarySignature: signature,
             sessionKeys: sessionKey,
@@ -340,13 +328,10 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
             // Proper typing is too complex, it will be removed to support only newer pmcrypto.
             verified: verified || verificationStatus!,
-        }
+        };
     }
 
-    async decryptArmored(
-        armoredData: string,
-        decryptionKeys: PrivateKey | PrivateKey[],
-    ) {
+    async decryptArmored(armoredData: string, decryptionKeys: PrivateKey | PrivateKey[]) {
         const { data } = await this.cryptoProxy.decryptMessage({
             armoredMessage: armoredData,
             decryptionKeys,
@@ -372,7 +357,7 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
             // Proper typing is too complex, it will be removed to support only newer pmcrypto.
             verified: verified || verificationStatus!,
-        }
+        };
     }
 
     async decryptArmoredAndVerifyDetached(
@@ -394,13 +379,10 @@ export class OpenPGPCryptoWithCryptoProxy implements OpenPGPCrypto {
             // pmcrypto 8.3.0 changes `verified` to `verificationStatus`.
             // Proper typing is too complex, it will be removed to support only newer pmcrypto.
             verified: verified || verificationStatus!,
-        }
+        };
     }
 
-    async decryptArmoredWithPassword(
-        armoredData: string,
-        password: string,
-    ) {
+    async decryptArmoredWithPassword(armoredData: string, password: string) {
         const { data } = await this.cryptoProxy.decryptMessage({
             armoredMessage: armoredData,
             passwords: [password],

package/src/crypto/utils.ts

@@ -4,7 +4,7 @@ export function uint8ArrayToBase64String(array: Uint8Array) {
     return encodeBase64(arrayToBinaryString(array));
 }
 
-export function base64StringToUint8Array(string: string){
+export function base64StringToUint8Array(string: string) {
     return binaryStringToArray(decodeBase64(string) || '');
 }
 

package/src/diagnostic/eventsGenerator.ts

@@ -0,0 +1,48 @@
+import { DiagnosticResult } from './interface';
+
+/**
+ * A base class for class that should provide diagnostic events
+ * as a separate generator. Simply inherit from this class and use
+ * `enqueueEvent` to enqueue the observed events. The events will be
+ * available via `iterateEvents` generator.
+ */
+export class EventsGenerator {
+    private eventQueue: DiagnosticResult[] = [];
+    private waitingResolvers: Array<() => void> = [];
+
+    protected enqueueEvent(event: DiagnosticResult): void {
+        this.eventQueue.push(event);
+        // Notify all waiting generators
+        const resolvers = this.waitingResolvers.splice(0);
+        resolvers.forEach((resolve) => resolve());
+    }
+
+    async *iterateEvents(): AsyncGenerator<DiagnosticResult> {
+        try {
+            while (true) {
+                if (this.eventQueue.length === 0) {
+                    await this.waitForEvent();
+                }
+
+                while (this.eventQueue.length > 0) {
+                    const event = this.eventQueue.shift();
+                    if (event) {
+                        yield event;
+                    }
+                }
+            }
+        } finally {
+            this.waitingResolvers.splice(0);
+        }
+    }
+
+    private waitForEvent(): Promise<void> {
+        return new Promise<void>((resolve) => {
+            if (this.eventQueue.length > 0) {
+                resolve();
+            } else {
+                this.waitingResolvers.push(resolve);
+            }
+        });
+    }
+}