@tdxvolt/volt-client-grpc 0.16.0-beta.9 → 0.18.0

package/protobuf/tdx/volt_api/volt/v1/wire_api.proto

@@ -22,6 +22,10 @@ message PublishWireRequest {
 
   // The chunk of data to publish.
   bytes chunk = 2;
+
+  // Whether to persist the chunk.
+  // This is only valid if the wire is configured to persist messages, i.e. the `volt:wire-persist` attribute is true.
+  bool do_not_persist = 3;
 }
 
 message PublishWireResponse {

package/src/constants.js

@@ -1,59 +1,10 @@
-// eslint-disable-next-line import/prefer-default-export
 export const constants = {
-  authTokenName: "tdx-token",
-  collectionOperation: {
-    add: "ADD",
-    remove: "REMOVE",
-    update: "UPDATE"
-  },
-  crypto: {
-    subjectDefaults: [
-      {
-        name: "countryName",
-        value: "GB"
-      },
-      {
-        name: "localityName",
-        value: "Southampton"
-      },
-      {
-        name: "organizationName",
-        value: "nquiringminds Ltd"
-      }
-    ],
-    userIdOID: "0.9.2342.19200300.100.1.1"
-  },
-  defaultDIDHostName: "cloud.tdxvolt.com",
+  authTokenName: "volt-token",
+  defaultDIDHostName: "tdxvolt.com",
   didServiceType: {
-    voltConfig: "tdx-volt-config"
-  },
-  identityType: {
-    did: "did",
-    volt: "volt"
-  },
-  onlineStatus: {
-    offline: "offline",
-    online: "online",
-    unknown: "unknown"
+    voltConfig: "volt-discovery"
   },
-  publicKeyPrefix: "-----BEGIN PUBLIC KEY-----",
-  privateKeyPrefix: "-----BEGIN RSA PRIVATE KEY-----",
   privateEncryptedKeyPrefix: "-----BEGIN ENCRYPTED PRIVATE KEY-----",
-  resource: {
-    identity: "ident",
-    identityView: "ident-view",
-    proxy: "proxy",
-    proxyView: "proxy-view",
-    vc: "vc",
-    vcView: "vc-view"
-  },
-  voltStatus: {
-    pending: "",
-    online: "online",
-    offline: "offline",
-    deleted: "deleted",
-    revoked: "revoked"
-  },
   /**
    * These top-level service types should map to a protobuf definition
    * in @tdxvolt/volt-proto.
@@ -66,10 +17,5 @@ export const constants = {
     relayAPI: "tdx.volt_api.relay.v1.RelayAPI",
     voltAPI: "tdx.volt_api.volt.v1.VoltAPI",
     wireAPI: "tdx.volt_api.volt.v1.WireAPI"
-  },
-  tunnelInvokeMethod: "/tdx.volt_api.volt.v1.VoltAPI/Invoke",
-  tunnelPingInterval: 10000,
-  tunnelPingTimeout: 2500,
-  tunnelReconnectAfter: 30000,
-  tunnelTimeoutInterval: 10000 * 2 // This must always be greater than `tunnelPingInterval`.
+  }
 };

package/src/grpc-call.js

@@ -1,7 +1,19 @@
 /* eslint-disable no-underscore-dangle */
 import debug from "debug";
 import EventEmitter from "events";
-import { VoltCredential } from "./volt-credential.js";
+import { voltUtils as voltClientUtils } from "@tdxvolt/volt-client-web/js";
+
+const {
+  aesCreateKey,
+  aesEncrypt,
+  aesDecrypt,
+  toBase64,
+  formatPEM,
+  keyFromPem,
+  verify,
+  deriveSharedKey,
+  x25519
+} = voltClientUtils;
 
 const log = debug("volt-client-grpc:grpc-call");
 
@@ -14,6 +26,21 @@ function _prepareInvokeRequest(
     this._service?.service_description.host_type ===
     "SERVICE_HOST_TYPE_RELAYED";
 
+  const relaying = this._voltClient.isVoltRelay || isServiceRelayed;
+
+  let targetDID = [];
+  if (this._voltClient.isVoltRelay) {
+    targetDID.push(this._voltClient.voltConfig.id);
+  }
+
+  if (isServiceRelayed) {
+    // Add another relay hop if the target service is relayed.
+    log("target service is relayed");
+    targetDID.push(this._service.service_description.host_client_id);
+  }
+
+  log("target is %j", targetDID);
+
   // Use the service's host client id and public key if the service is relayed.
   const methodToken = this._voltClient.credential.getIdentityMetadata(
     this._voltClient.grpc,
@@ -21,17 +48,52 @@ function _prepareInvokeRequest(
       this._voltClient.voltConfig.id,
     this._service?.service_description.host_public_key ||
       this._voltClient.credential.voltPublicKey,
-    true
+    relaying
   );
 
   let invokeRequest;
   let callMethod = method;
 
-  if (this._voltClient.isVoltRelay || isServiceRelayed) {
+  if (relaying) {
     //
     // If the volt connection is via a relay (or the target service is relayed),
     // we wrap the rpc in a RemoteRequest message and send it via a call to Invoke().
     //
+    // Replace the target method with a call to Invoke on the relay Volt.
+    //
+    callMethod = "Invoke";
+
+    // But first we need to perform a key exchange with the target service.
+    //
+    if (!this._encryptionKey) {
+      // We haven't exchanged keys yet, so queue the payload.
+      this._pendingRequests.push(request);
+
+      if (this._keyExchangePending) {
+        // We've already sent the key exchange request, so do nothing.
+        log("key exchange pending, not sending payload");
+        return;
+      }
+
+      this._keyExchangePending = true;
+
+      // Send the key exchange request.
+      invokeRequest = {
+        token: methodToken.token,
+        target_did: targetDID,
+        target_service_id: isServiceRelayed
+          ? this._service.service_description.host_service_id
+          : undefined
+      };
+
+      return {
+        request: invokeRequest,
+        method: callMethod,
+        methodName: method,
+        meta: methodToken
+      };
+    }
+
     let requestPayload;
 
     // Serialise the rpc request.
@@ -51,45 +113,24 @@ function _prepareInvokeRequest(
       method_invoke: {
         method_name: this._grpcClient[method].path,
         method_type: methodType,
-        token: methodToken.token,
         request: requestPayload
       }
     };
 
-    let targetDID = [];
     let invokePayload;
-    if (this._voltClient.isVoltRelay || isServiceRelayed) {
-      // When sending via a relay we need to encrypt the payload.
-      invokePayload = VoltCredential.aesEncrypt(
-        tunnelMethod.responseSerialize(tunnelResp),
-        methodToken.sharedKey.key,
-        methodToken.sharedKey.iv
-      );
-    } else {
-      invokePayload = tunnelMethod.responseSerialize(tunnelResp);
-    }
-
-    if (this._voltClient.isVoltRelay) {
-      targetDID.push(this._voltClient.voltConfig.id);
-    }
+    const iv = aesCreateKey().iv;
 
-    if (isServiceRelayed) {
-      // Add another relay hop if the target service is relayed.
-      log("target service is relayed");
-      targetDID.push(this._service.service_description.host_client_id);
-    }
-
-    log("target is %j", targetDID);
+    // When sending via a relay we need to encrypt the payload.
+    invokePayload = aesEncrypt(
+      this._encryptionKey,
+      iv,
+      tunnelMethod.responseSerialize(tunnelResp)
+    );
 
     invokeRequest = {
-      target_did: targetDID,
-      token: methodToken.token,
-      payload: invokePayload,
-      target_service_id: isServiceRelayed ? this._service.id : undefined
+      iv,
+      payload: invokePayload
     };
-
-    // Replace the target method with a call to Invoke on the relay Volt.
-    callMethod = "Invoke";
   } else {
     invokeRequest = request;
   }
@@ -109,7 +150,10 @@ function _preparePayloadRequest(request, invokeInfo) {
     this._service?.service_description.host_type ===
     "SERVICE_HOST_TYPE_RELAYED";
 
+  let iv;
   if (this._voltClient.isVoltRelay || isServiceRelayed) {
+    iv = aesCreateKey().iv;
+
     const requestPayload =
       this._grpcClient[invokeInfo.methodName].requestSerialize(request);
 
@@ -122,13 +166,14 @@ function _preparePayloadRequest(request, invokeInfo) {
       }
     };
 
-    const invokePayload = VoltCredential.aesEncrypt(
-      tunnelMethod.responseSerialize(tunnelResp),
-      invokeInfo.meta.sharedKey.key,
-      invokeInfo.meta.sharedKey.iv
+    const invokePayload = aesEncrypt(
+      this._encryptionKey,
+      iv,
+      tunnelMethod.responseSerialize(tunnelResp)
     );
 
     payloadRequest = {
+      iv,
       payload: invokePayload
     };
   } else {
@@ -147,13 +192,38 @@ function _parseResponse(method, meta, response) {
     "SERVICE_HOST_TYPE_RELAYED";
 
   if (this._voltClient.isVoltRelay || isServiceRelayed) {
-    if (response.payload) {
+    if (response.key_exchange) {
+      const encryptionKey = response.key_exchange.encryption_key;
+      const nonce = response.key_exchange.nonce;
+      const signature = response.key_exchange.signature;
+
+      // The signed message is the encryption key and the nonce.
+      const message = new Uint8Array(encryptionKey.length + nonce.length);
+      message.set(encryptionKey);
+      message.set(nonce, encryptionKey.length);
+
+      // Check the signature using the target service public key.
+      const targetKey = keyFromPem(
+        this._service?.service_description?.host_public_key ||
+          this._voltClient.credential.voltPublicKey
+      ).publicKey;
+
+      if (!verify(targetKey, message, signature)) {
+        throw new Error("signature verification failed");
+      }
+
+      invokeResponse = {
+        key_exchange: {
+          encryption_key: formatPEM(toBase64(encryptionKey), "PUBLIC KEY")
+        }
+      };
+    } else if (response.payload) {
       let decryptedPayload;
-      if (meta.sharedKey.key) {
-        decryptedPayload = VoltCredential.aesDecrypt(
-          response.payload,
-          meta.sharedKey.key,
-          meta.sharedKey.iv
+      if (this._encryptionKey) {
+        decryptedPayload = aesDecrypt(
+          this._encryptionKey,
+          response.iv,
+          response.payload
         );
       } else {
         decryptedPayload = response.payload;
@@ -193,11 +263,11 @@ function _parseResponse(method, meta, response) {
       invokeResponse.methodId = response.invoke_id;
       log("started method %d for %s", invokeResponse.methodId, method);
     }
-  } else if (this._voltClient.isRemote && meta.sharedKey.key) {
-    const decryptedPayload = VoltCredential.aesDecrypt(
-      response,
-      meta.sharedKey.key,
-      meta.sharedKey.iv
+  } else if (this._voltClient.isRemote && this._encryptionKey) {
+    const decryptedPayload = aesDecrypt(
+      this._encryptionKey,
+      meta.sharedKey.iv,
+      response
     );
     invokeResponse = {
       payload:
@@ -218,6 +288,9 @@ export default class GRPCCall extends EventEmitter {
     this._call = null;
     this._voltClient = voltClient;
     this._service = service;
+    this._keyExchangePending = false;
+    this._pendingRequests = [];
+    this._encryptionKey = null;
   }
 
   start(grpcClient, request) {
@@ -246,7 +319,7 @@ export default class GRPCCall extends EventEmitter {
     }
 
     this._call = callClient[this._initialRequest.method](
-      this._initialRequest.meta.metadata
+      this._initialRequest?.meta?.metadata
     );
 
     this._call.on("data", (streamResponse) => {
@@ -257,7 +330,25 @@ export default class GRPCCall extends EventEmitter {
           this._initialRequest.meta,
           streamResponse
         );
-        if (parsedResponse.payload) {
+        if (parsedResponse.key_exchange) {
+          const peerKey = keyFromPem(
+            parsedResponse.key_exchange.encryption_key
+          ).publicKey;
+
+          this._encryptionKey = deriveSharedKey(
+            this._initialRequest.meta.sharedKey.key,
+            peerKey,
+            x25519
+          );
+
+          // We've exchanged keys, so send any queued payloads on the next tick.
+          process.nextTick(() => {
+            this._pendingRequests.forEach((pendingRequest) => {
+              this.write(pendingRequest);
+            });
+            this._pendingRequests = [];
+          });
+        } else if (parsedResponse.payload) {
           // Interpret a non-empty status message as an error.
           if (parsedResponse.payload?.status?.message) {
             this.emit(
@@ -332,7 +423,7 @@ export default class GRPCCall extends EventEmitter {
     if (!this._call) {
       log("ERROR - call not initialised");
       throw new Error("call not initialised");
-    } else if (this._initialRequest) {
+    } else if (this._initialRequest && !this._keyExchangePending) {
       const payloadRequest = _preparePayloadRequest.call(
         this,
         request,
@@ -340,6 +431,8 @@ export default class GRPCCall extends EventEmitter {
       );
       return this._call.write(payloadRequest);
     } else {
+      this._keyExchangePending = false;
+
       this._initialRequest = _prepareInvokeRequest.call(
         this,
         request,

package/src/grpc-utils.js

@@ -20,8 +20,11 @@ export function createClient(
 ) {
   let grpcCredentials;
   if (credentials) {
-    const ca = credentials.config?.volt?.relay?.ca_pem || credentials.cache.ca;
-    const cert = credentials.cache.cloud_cert || credentials.cache.cert;
+    const relaying = !!credentials.config?.volt?.relay;
+    const ca = relaying
+      ? credentials.config?.volt?.relay?.ca_pem
+      : credentials.cache.ca;
+    const cert = relaying ? "" : credentials.cache.cert;
     const { key } = credentials.cache;
 
     if (key && cert) {
@@ -33,8 +36,9 @@ export function createClient(
         tlsOptions.cert
       );
     } else {
-      // Cache has no private key, this implies we are connecting without supplying a client certificate.
-      // Simply connect using the CA certificate.
+      // Cache has no private key or certificate, this implies we are connecting without supplying a client certificate.
+      // We might be connecting to a relay, or making an initial Authenticate call.
+      // Simply connect using the CA certificate, and the a JWT will be used to authenticate.
       grpcCredentials = grpc.credentials.createSsl(Buffer.from(ca));
     }
   } else {

package/src/rpc-invocation.js

@@ -1,7 +1,23 @@
 import debug from "debug";
-import { VoltCredential } from "./volt-credential.js";
 import jwt from "jsonwebtoken";
 import EventEmitter from "events";
+import { voltUtils as voltClientUtils } from "@tdxvolt/volt-client-web/js";
+
+const {
+  aesDecrypt,
+  aesEncrypt,
+  createEncryptionKey,
+  deriveSharedKey,
+  formatPEM,
+  fromBase64,
+  fromBase64Url,
+  keyFromPem,
+  publicKeyToPem,
+  randomBytes,
+  signBase64,
+  stripPEMHeaders,
+  x25519
+} = voltClientUtils;
 
 const log = debug("rpc-invocation");
 
@@ -9,13 +25,13 @@ class RpcInvocation extends EventEmitter {
   #voltClient = null;
   #voltConnection = null;
   #token = null;
-  #encryptKey = null;
-  #encryptIV = null;
   #invokeId = null;
   #payload = null;
   #isJSON = false;
   #methodDescriptor = null;
   #methodName = null;
+  #derivedKey = null;
+  #started = false;
 
   constructor(voltClient, voltConnection) {
     super();
@@ -59,51 +75,89 @@ class RpcInvocation extends EventEmitter {
     this.#methodDescriptor = methodDescriptor;
   }
 
-  #decodeToken(token) {
+  get started() {
+    return this.#started;
+  }
+
+  #keyExchange(token) {
     // We don't verify the token at this point, as we don't know the public key.
     // The rpc implementation should do the verification using the Volt API (e.g. CanAccessResource).
     this.#token = jwt.decode(token);
 
-    if (this.#token.sk) {
-      // Decrypt the shared key and iv using the private key.
-      this.#encryptKey = VoltCredential.rsaDecrypt(
-        this.#voltClient.credential.cache.key,
-        this.#token.sk
-      );
-      this.#encryptIV = VoltCredential.rsaDecrypt(
-        this.#voltClient.credential.cache.key,
-        this.#token.iv
-      );
-    }
+    // Store the JWT key id (kid) for use in the response.
+    const callerPublicKeyPem = formatPEM(this.#token.k, "PUBLIC KEY");
+    const callerKey = keyFromPem(callerPublicKeyPem, "", x25519).publicKey;
+
+    const ephemeralKeyPem = createEncryptionKey();
+    const ephemeralKey = keyFromPem(ephemeralKeyPem, "", x25519);
+    const ephemeralPublicKey = fromBase64(
+      stripPEMHeaders(publicKeyToPem(ephemeralKey.publicKey, x25519))
+    );
+
+    this.#derivedKey = deriveSharedKey(
+      ephemeralKey.privateKey,
+      callerKey,
+      x25519
+    );
+
+    const nonce = randomBytes(16);
+
+    // The signed message is the encryption key and the nonce.
+    const message = new Uint8Array(ephemeralPublicKey.length + nonce.length);
+    message.set(ephemeralPublicKey);
+    message.set(nonce, ephemeralPublicKey.length);
+
+    const signature = signBase64(
+      this.#voltClient.credential.getKey().privateKey,
+      message
+    );
+
+    const keyExchangeResponse = {
+      invoke_id: this.#invokeId,
+      key_exchange: {
+        nonce,
+        encryption_key: ephemeralPublicKey,
+        signature: fromBase64Url(signature)
+      }
+    };
+
+    this.#voltConnection.send({
+      invoke_response: keyExchangeResponse
+    });
 
-    return Promise.resolve(this.#token);
+    return Promise.resolve(keyExchangeResponse);
   }
 
   initialise(invoke_request) {
     this.#invokeId = invoke_request.invoke_id;
 
-    return this.#decodeToken(invoke_request.token)
-      .then(() => {
-        // Parse the initial payload.
-        return this.parsePayload(invoke_request);
-      })
-      .catch((err) => {
+    if (!this.#derivedKey) {
+      // We don't have the derived key yet, so we need to perform the key exchange.
+      return this.#keyExchange(invoke_request.token).catch((err) => {
         log("failure initialising invocation: %s", err.message);
         return Promise.reject(err);
       });
+    } else {
+      // We already have the derived key, so we can just parse the payload.
+      return this.parsePayload(invoke_request);
+    }
   }
 
   parsePayload(invoke_request) {
+    this.#started = true;
+
     return new Promise((resolve, reject) => {
+      const encryptIV = invoke_request.iv;
+
       if (invoke_request.payload) {
         let decryptedPayload;
 
-        if (this.#encryptKey) {
+        if (encryptIV) {
           // Decrypt the actual payload using the shared key and iv.
-          decryptedPayload = VoltCredential.aesDecrypt(
-            invoke_request.payload,
-            this.#encryptKey,
-            this.#encryptIV
+          decryptedPayload = aesDecrypt(
+            this.#derivedKey,
+            encryptIV,
+            invoke_request.payload
           );
         } else {
           // No encryption => just use the payload.
@@ -139,12 +193,12 @@ class RpcInvocation extends EventEmitter {
 
         this.#isJSON = true;
 
-        if (this.#encryptKey) {
+        if (this.#derivedKey) {
           // Decrypt the actual payload using the shared key and iv.
-          decryptedPayload = VoltCredential.aesDecrypt(
-            Buffer.from(invoke_request.json_payload, "base64"),
-            this.#encryptKey,
-            this.#encryptIV
+          decryptedPayload = aesDecrypt(
+            this.#derivedKey,
+            invoke_request.iv,
+            Buffer.from(invoke_request.json_payload, "base64")
           );
         } else {
           // No encryption => just use the payload.
@@ -203,17 +257,15 @@ class RpcInvocation extends EventEmitter {
       });
     }
 
-    if (this.#token.sk) {
+    const iv = randomBytes(16);
+    if (this.#derivedKey) {
       // Encrypt the response using the shared key and iv.
-      responsePayload = VoltCredential.aesEncrypt(
-        responsePayload,
-        this.#encryptKey,
-        this.#encryptIV
-      );
+      responsePayload = aesEncrypt(this.#derivedKey, iv, responsePayload);
     }
 
     const invokeResponse = {
-      invoke_id: this.#invokeId
+      invoke_id: this.#invokeId,
+      iv
     };
 
     if (this.#isJSON) {
@@ -248,18 +300,16 @@ class RpcInvocation extends EventEmitter {
       endPayload = tunnelMethod.requestSerialize(endPayload);
     }
 
-    if (this.#token.sk) {
+    const iv = randomBytes(16);
+    if (this.#derivedKey) {
       // Encrypt the response using the shared key and iv.
-      endPayload = VoltCredential.aesEncrypt(
-        endPayload,
-        this.#encryptKey,
-        this.#encryptIV
-      );
+      endPayload = aesEncrypt(this.#derivedKey, iv, endPayload);
     }
 
     const invokeResponse = {
       invoke_id: this.#invokeId,
-      server_end: true
+      server_end: true,
+      iv
     };
 
     if (this.#isJSON) {