@peers-app/peers-sdk 0.7.28 → 0.7.39

package/dist/device/connection.d.ts

@@ -11,7 +11,7 @@ export declare class Connection {
     private _remoteDeviceInfo;
     secureLocal: boolean;
     secureRemote: boolean;
-    forceInsecure: boolean;
+    overrideEncryption?: 'encrypt-traffic-regardless-of-protocol' | 'dont-encrypt-traffic-after-handshake';
     trustLevel: TrustLevel;
     onHandshakeComplete: ((deviceInfo: IDeviceInfo) => void) | undefined;
     timeoutMs: number;
@@ -22,7 +22,7 @@ export declare class Connection {
     readonly socket: ISocket;
     constructor(socket: ISocket, localDevice: Device, localDeviceServerAddresses?: string[] | undefined, getTrustLevel?: GetTrustLevel);
     get verified(): boolean;
-    get secure(): boolean;
+    get encryptTraffic(): boolean;
     get remoteDeviceInfo(): {
         userId: string;
         deviceId: string;

package/dist/device/connection.js

@@ -20,11 +20,7 @@ class Connection {
     };
     secureLocal = false;
     secureRemote = false;
-    // TODO this concept of insecure needs to be adjusted
-    // what it actually means is that the underlying connection _is_ secure
-    // OR that both the client and server want to skip encryption (which we maybe shouldn't allow)
-    // webRTC connections _are_ secure so we'll be setting `forceInsecure` to true (which is a misnomer)
-    forceInsecure = false;
+    overrideEncryption;
     trustLevel = socket_type_1.TrustLevel.Unknown;
     onHandshakeComplete;
     timeoutMs = 60_000; // 60 seconds
@@ -68,18 +64,21 @@ class Connection {
             });
             this.exposeRPC('requestSecure', () => {
                 this.secureRemote = true;
-                return this.secure;
+                return !this.encryptTraffic;
             });
         }
     }
     get verified() {
         return this._verified;
     }
-    get secure() {
-        if (this.forceInsecure) {
+    get encryptTraffic() {
+        if (this.overrideEncryption === 'dont-encrypt-traffic-after-handshake') {
             return false;
         }
-        return this.secureLocal && this.secureRemote;
+        if (this.overrideEncryption === 'encrypt-traffic-regardless-of-protocol') {
+            return true;
+        }
+        return !(this.secureLocal && this.secureRemote);
     }
     get remoteDeviceInfo() {
         return { ...this._remoteDeviceInfo };
@@ -102,7 +101,7 @@ class Connection {
     emit(eventName, ...args) {
         return new Promise((resolve, reject) => {
             try {
-                if (this._verified && !this.secure) {
+                if (this._verified && this.encryptTraffic) {
                     args = this.localDevice.signAndBoxDataForDevice(args, this._remoteDeviceInfo);
                 }
                 const timeoutMs = this.timeoutMs;
@@ -120,7 +119,7 @@ class Connection {
                             this.secureRemote = this.localDevice.unwrapResponse(result);
                             result = this.secureRemote;
                         }
-                        else if (this._verified && !this.secure) {
+                        else if (this._verified && this.encryptTraffic) {
                             // this purposely results in an error if the client is not securing the data when it should be
                             result = this.localDevice.openBoxedAndSignedData(result);
                         }
@@ -150,11 +149,11 @@ class Connection {
             }
             let result;
             try {
-                if (this._verified && !this.secure) {
+                if (this._verified && this.encryptTraffic) {
                     args = this.localDevice.openBoxedAndSignedData(args);
                 }
                 result = await handler(...args);
-                if (this._verified && !this.secure) {
+                if (this._verified && this.encryptTraffic) {
                     result = this.localDevice.signAndBoxDataForDevice(result, this._remoteDeviceInfo);
                 }
                 callback(null, result);
@@ -162,7 +161,7 @@ class Connection {
             catch (e) {
                 console.error(`Error handling ${eventName}(${JSON.stringify(args)})`, e);
                 let rpcError = { error: e.message, errorType: 'RPC_ERROR' };
-                if (this._verified && !this.secure) {
+                if (this._verified && this.encryptTraffic) {
                     try {
                         rpcError = this.localDevice.signAndBoxDataForDevice(rpcError, this._remoteDeviceInfo);
                     }
@@ -188,7 +187,6 @@ class Connection {
         this._verified = false;
         this.secureLocal = false;
         this.secureRemote = false;
-        this.forceInsecure = false;
         this.trustLevel = socket_type_1.TrustLevel.Unknown;
     }
     initiateHandshake(serverAddress, remoteDeviceInfo) {
@@ -254,7 +252,9 @@ class Connection {
         }
         this._verified = true;
         this._connectionAddress = remoteAddress;
-        this.secureLocal = handshakeResponse.serverAddress === remoteAddress && remoteAddress.startsWith('https');
+        const secureProtocols = ['https', 'wss', 'wrtc', 'libp2p'];
+        // const secureProtocols = ['https', 'wss',]
+        this.secureLocal = secureProtocols.some(s => remoteAddress.startsWith(s)) && handshakeResponse.serverAddress === remoteAddress;
         if (this.secureLocal) {
             await this.emit('requestSecure');
         }

package/dist/device/connection.test.js

@@ -90,10 +90,10 @@ describe(connection_1.Connection, () => {
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
         const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['https://localhost']);
         await clientConnection.doHandshake('https://localhost');
-        expect(clientConnection.secure).toBe(true);
+        expect(clientConnection.encryptTraffic).toBe(false);
         // and allow forcing insecure
-        clientConnection.forceInsecure = true;
-        expect(clientConnection.secure).toBe(false);
+        clientConnection.overrideEncryption = 'encrypt-traffic-regardless-of-protocol';
+        expect(clientConnection.encryptTraffic).toBe(true);
         // and only return a copy of the remoteDeviceInfo
         expect(clientConnection.remoteDeviceInfo).not.toBe(clientConnection.remoteDeviceInfo);
     });
@@ -104,9 +104,8 @@ describe(connection_1.Connection, () => {
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
         const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['https://localhost']);
         await clientConnection.doHandshake('https://localhost');
-        // for secure connections
-        expect(clientConnection.secure).toBe(true);
-        expect(serverConnection.secure).toBe(true);
+        expect(clientConnection.encryptTraffic).toBe(false);
+        expect(serverConnection.encryptTraffic).toBe(false);
         serverConnection.exposeRPC('ping', async () => { throw new Error("fake error"); });
         const response = await clientConnection.emit('ping').catch((err) => err);
         expect(response).toEqual({
@@ -121,9 +120,8 @@ describe(connection_1.Connection, () => {
         const clientConnection = new connection_1.Connection(clientSocket, clientDevice);
         const serverConnection = new connection_1.Connection(serverSocket, serverDevice, ['http://localhost']);
         await clientConnection.doHandshake('http://localhost');
-        // for secure connections
-        expect(clientConnection.secure).toBe(false);
-        expect(serverConnection.secure).toBe(false);
+        expect(clientConnection.encryptTraffic).toBe(true);
+        expect(serverConnection.encryptTraffic).toBe(true);
         serverConnection.exposeRPC('ping', async () => { throw new Error("fake error"); });
         const response = await clientConnection.emit('ping').catch((err) => err);
         expect(response).toEqual({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.7.28",
+  "version": "0.7.39",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"