@lifeready/core 6.1.3 → 6.1.5

package/esm2015/lib/key-exchange/key-exchange.service.js

@@ -0,0 +1,480 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, Injector, NgZone } from '@angular/core';
+import { LrMutation, LrService } from '../api/lr-graphql';
+import { EncryptionService, JoseSerialization, } from '../encryption/encryption.service';
+import { KeyFactoryService } from '../key/key-factory.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { KeyService } from '../key/key.service';
+import { KcCodeMismatchException } from '../_common/exceptions';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import { CancelKeyExchangeMutation, CompleteKeyExchangeOtkMutation, CurrentUserSharedKeyQuery2, DeclineKeyExchangeMutation, InitiateKeyExchangeOtkMutation, KeyExchangeQuery2, KeyExchangesQuery2, KeyExchangeTokenQuery2, RespondKeyExchangeOtkMutation, } from './key-exchange.gql';
+import * as i0 from "@angular/core";
+import * as i1 from "../key/key-factory.service";
+import * as i2 from "../key/key.service";
+import * as i3 from "../encryption/encryption.service";
+import * as i4 from "../key/key-graph.service";
+let KeyExchangeService = class KeyExchangeService extends LrService {
+    constructor(ngZone, injector, keyFactory, keyService, encryptionService, keyGraph) {
+        super(injector);
+        this.ngZone = ngZone;
+        this.injector = injector;
+        this.keyFactory = keyFactory;
+        this.keyService = keyService;
+        this.encryptionService = encryptionService;
+        this.keyGraph = keyGraph;
+        this.CLIENT_NONCE_LENGTH = 32;
+    }
+    getOtKey(keyExchange, otKeyK) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (otKeyK) {
+                return yield KeyFactoryService.asKey(Object.assign(Object.assign({}, JSON.parse(keyExchange.otk.otKeyParams)), { k: otKeyK }));
+            }
+            else if (keyExchange.otk.state === 'OTK_INITIATED' &&
+                !keyExchange.isInitiator &&
+                keyExchange.otk.responderPbkCipher) {
+                // Assuming existing user getting invited where OTK is wrapped in responder's public key.
+                const prk = this.keyService.currentPxk;
+                const decryptedCipher = yield this.encryptionService.decrypt(prk.jwk, JSON.parse(keyExchange.otk.responderPbkCipher), {
+                    serializations: [JoseSerialization.COMPACT],
+                });
+                if (decryptedCipher.otKey) {
+                    return yield KeyFactoryService.asKey(decryptedCipher.otKey);
+                }
+            }
+            return null;
+        });
+    }
+    decryptOtk(keyExchange, otKeyK) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const otKey = yield this.getOtKey(keyExchange, otKeyK);
+            let otk = keyExchange.otk;
+            if (otKey && otk.otKeyCipher) {
+                otk = Object.assign(Object.assign({}, otk), { otKey, otKeyCipherClearJson: yield this.encryptionService.decrypt(otKey, keyExchange.otk.otKeyCipher) });
+            }
+            return Object.assign(Object.assign({}, keyExchange), { otk });
+        });
+    }
+    decryptResponseCipher(otKey, otPrk, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // The response could be wrapped by the OtK in addition to the OtPbk
+            try {
+                content = yield this.encryptionService.decrypt(otKey, content);
+            }
+            catch (error) {
+                if (error.message !== 'no key found') {
+                    throw error;
+                }
+                // Do nothing to support older versions where message is not wrapped with otk.
+            }
+            // The Prk is single-use and only used to send information from the responder back to the initiator.
+            return yield this.encryptionService.decrypt(otPrk, content);
+        });
+    }
+    decryptKeyExchangeAsInitiator(keyExchange) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rootKey = this.keyService.currentRootKey;
+            // Decrypt using the root key to get the Prk
+            const initiatorRootKeyCipherClearJson = (yield this.encryptionService.decrypt(rootKey.jwk, keyExchange.initiatorRootKeyCipher));
+            const otKey = yield KeyFactoryService.asKey(initiatorRootKeyCipherClearJson.otKey);
+            keyExchange = Object.assign(Object.assign({}, keyExchange), { initiatorRootKeyCipherClearJson });
+            let otk = keyExchange.otk;
+            if (otk.initiatorOneTimePbkCipher) {
+                otk = Object.assign(Object.assign({}, otk), { initiatorOneTimePbkCipherClearJson: yield this.decryptResponseCipher(otKey, yield KeyFactoryService.asKey(initiatorRootKeyCipherClearJson.oneTimePrk), otk.initiatorOneTimePbkCipher) });
+            }
+            if (otk.otKeyCipher) {
+                otk.otKeyCipherClearJson = yield this.encryptionService.decrypt(otKey, otk.otKeyCipher);
+            }
+            return Object.assign(Object.assign({}, keyExchange), { otk });
+        });
+    }
+    decryptKeyExchangeAsResponder(keyExchange, otKeyK) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.decryptOtk(keyExchange, otKeyK);
+        });
+    }
+    decryptKeyExchange(keyExchange, otKeyK) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (keyExchange.isInitiator) {
+                return this.decryptKeyExchangeAsInitiator(keyExchange);
+            }
+            else {
+                return this.decryptKeyExchangeAsResponder(keyExchange, otKeyK);
+            }
+        });
+    }
+    getKeyExchanges({ state } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { keyExchanges } = yield this.query({
+                query: KeyExchangesQuery2,
+                variables: {
+                    state,
+                },
+            });
+            return Promise.all(keyExchanges.edges.map((edge) => this.decryptKeyExchange(edge.node)));
+        });
+    }
+    /**
+     * @param id If the current user can responder the key exchange if they are either the initiator or the receiver.
+     * @param token If not signed in, or not the initiator or responder, 'token' must be given.
+     * @param otKeyK Is the raw one-time key (string). If the responder is explicitly specified at time of initiation, then
+     *   it's possible to have the otKey wrapped by the public key of the responder. In which case, the otKeyK is not needed.
+     */
+    getKeyExchange(id, { otKeyK, token } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.query({
+                query: token ? KeyExchangeTokenQuery2 : KeyExchangeQuery2,
+                variables: {
+                    id,
+                    token,
+                },
+                includeKeyGraph: !token,
+            });
+            return this.decryptKeyExchange(res.keyExchange, otKeyK);
+        });
+    }
+    getCurrentUserSharedKey(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.query({
+                query: CurrentUserSharedKeyQuery2,
+                variables: {
+                    username: input.username,
+                    userId: input.userId,
+                },
+            });
+        });
+    }
+    cancelKeyExchange(id) {
+        return this.mutate(this.cancelKeyExchangeMutation(id));
+    }
+    cancelKeyExchangeMutation(id) {
+        return new LrMutation({
+            mutation: CancelKeyExchangeMutation,
+            variables: {
+                input: {
+                    id,
+                },
+            },
+        });
+    }
+    declineKeyExchange(id, token) {
+        return this.mutate(this.declineKeyExchangeMutation(id, token));
+    }
+    declineKeyExchangeMutation(id, token) {
+        return new LrMutation({
+            mutation: DeclineKeyExchangeMutation,
+            variables: {
+                input: {
+                    id,
+                    token,
+                },
+            },
+        });
+    }
+    initiateOtk(input = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mutate((yield this.initiateOtkMutation(input)).lrMutation);
+        });
+    }
+    initiateOtkMutation({ message, email, contactCard, upgrade, } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const otKey = yield this.keyFactory.createKey();
+            const nonce = this.keyFactory.randomString(this.CLIENT_NONCE_LENGTH);
+            // New PKC key for encryption. This key is used only once when the responder sends
+            // back their signing public key.
+            const initiatorOneTimePrk = yield this.keyFactory.createPkcKey();
+            // Option 1: New PKC key for signing
+            // const initiatorSigPrk = await this.keyService.createPkcSignKey();
+            // Option 2: Use the user's global signing key.
+            // This key is used to prove the initiator's identity.
+            const initiatorPrk = this.keyService.currentPxk;
+            const initiatorSigPrk = this.keyService.currentSigPxk;
+            let initiatorPlainDataSig = null;
+            if (contactCard && contactCard.ownerPlainDataJson) {
+                initiatorPlainDataSig = yield this.encryptionService.signToString(initiatorSigPrk.jwk, contactCard.ownerPlainDataJson);
+            }
+            const initiator = {
+                message,
+                contactCard: contactCard && {
+                    sharedCipherDataClearJson: contactCard.sharedCipherDataClearJson,
+                },
+            };
+            // Content to be encrypted using the OTK.
+            const plainOtKeyCipher = {
+                // TODO Make sure we also put the OOB code in here as well since the OOB code is the
+                // _only_ information the KC server does not have access to. The server may have
+                // access to OTK and hence the nonce here. It's good to have both the nonce and OOB code
+                // since the user may not be using the OOB code. And it's simple to always include
+                // the nonce, so why not.
+                nonce,
+                initiator: Object.assign(Object.assign({}, initiator), { oneTimePbk: initiatorOneTimePrk.toJSON(), pbk: initiatorPrk.jwk.toJSON(), sigPbk: initiatorSigPrk.jwk.toJSON() }),
+            };
+            const otKeyCipher = yield this.keyGraph.encryptToString(otKey, plainOtKeyCipher);
+            // Content to be encrypted using the initiator's root key.
+            const initiatorRootKeyCipherClearJson = {
+                nonce,
+                oneTimePrk: initiatorOneTimePrk.toJSON(true),
+                // Should not need to keep this encrypted since we are using the global signing key.
+                // sigPrk: initiatorSigPrk.toJSON(true),
+                // Save it in case the initiator want to decode the otKeyCipher.
+                // Since the otKey is only used once, and that otKeyCipher contains only
+                // the public key of the initiator, it's safe just leave the otKey stored here.
+                otKey: otKey.toJSON(true),
+                // These should be storing information such as how the fields of the shared contact card is
+                // derived from the master contact card.
+                initiatorContactCard: contactCard,
+                initiator,
+            };
+            const rootKey = this.keyService.currentRootKey;
+            const initiatorRootKeyCipher = yield this.keyGraph.encryptToString(rootKey.jwk, initiatorRootKeyCipherClearJson);
+            // The raw OTK
+            const otKeyK = otKey.toJSON(true).k;
+            // API call
+            const lrMutation = new LrMutation({
+                mutation: InitiateKeyExchangeOtkMutation,
+                variables: {
+                    input: {
+                        // These will be stored on the server
+                        initiatorRootKeyCipher,
+                        initiatorPxkId: initiatorPrk.id,
+                        initiatorSigPxkId: initiatorSigPrk.id,
+                        // These will be sent to the responder
+                        otKeyParams: JSON.stringify(otKey.toJSON()),
+                        otKeyCipher,
+                        sendEmail: email && {
+                            email,
+                            rawOtKey: otKeyK,
+                        },
+                        createTp: true,
+                        initiatorPlainDataSig,
+                        upgrade,
+                    },
+                },
+            });
+            return { lrMutation, otKeyK };
+        });
+    }
+    respondOtk(input) {
+        return this.mutate(this.respondOtkMutation(input));
+    }
+    respondOtkMutation({ keyExchangeId, token, decryptedOtk, message, initiatorContactCard, responderContactCard, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rootKey = this.keyService.currentRootKey;
+            const masterKey = this.keyService.currentMasterKey;
+            const sharedKey = yield this.keyFactory.createKey();
+            const mkSharedKey = yield this.keyFactory.createKey();
+            const rkWrappedSharedKey = yield this.encryptionService.encrypt(rootKey.jwk, sharedKey.toJSON(true));
+            const mkWrappedMkSharedKey = yield this.encryptionService.encrypt(masterKey.jwk, mkSharedKey.toJSON(true));
+            const initiatorOneTimePbk = yield KeyFactoryService.asKey(decryptedOtk.otKeyCipherClearJson.initiator.oneTimePbk);
+            const initiatorPbk = yield KeyFactoryService.asKey(decryptedOtk.otKeyCipherClearJson.initiator.pbk);
+            const initiatorSigPbk = yield KeyFactoryService.asKey(decryptedOtk.otKeyCipherClearJson.initiator.sigPbk);
+            // Option 1: Using new Prk for each TP pair
+            // Create a new public signing key for the responder.
+            // const responderSigPrk = await this.keyService.createPkcSignKey()
+            // const rkWrappedResponderSigPrk = await this.encrypt(rootKey, responderSigPrk.toJSON(true));
+            // Option 2: Responder already has a signing Prk
+            const responderPrk = this.keyService.currentPxk;
+            const responderSigPrk = this.keyService.currentSigPxk;
+            const signedInitiatorPbk = yield this.encryptionService.sign(responderSigPrk.jwk, initiatorPbk.toJSON());
+            const signedInitiatorSigPbk = yield this.encryptionService.sign(responderSigPrk.jwk, initiatorSigPbk.toJSON());
+            const initiatorOneTimePbkCipherClearJson = {
+                nonce: decryptedOtk.otKeyCipherClearJson.nonce,
+                sharedKey: sharedKey.toJSON(true),
+                mkSharedKey: mkSharedKey.toJSON(true),
+                responder: {
+                    pbk: responderPrk.jwk.toJSON(),
+                    sigPbk: responderSigPrk.jwk.toJSON(),
+                    message,
+                },
+            };
+            let receivedCardInput;
+            if (decryptedOtk.otKeyCipherClearJson.initiator.contactCard) {
+                // Set the info about the initiator to be the ones sent by the initiator. We need th responder to do the encryption here
+                // because the initiator does not have the shared key yet, and we want the responder to have a functional contact card after
+                // this exchange. The initiator can double check the contact details are correct and sign it when it completes the exchange.
+                const sharedCipherDataClearJson = decryptedOtk.otKeyCipherClearJson.initiator.contactCard
+                    .sharedCipherDataClearJson;
+                // Create keys
+                const receiverKey = yield this.keyFactory.createKey();
+                const ccSharedKey = yield this.keyFactory.createKey();
+                const sigPxk = this.keyService.currentSigPxk;
+                receivedCardInput = {
+                    receiverWrappedKey: JSON.stringify(yield this.encryptionService.encrypt(rootKey.jwk, receiverKey.toJSON(true))),
+                    receiverWrappingKeyId: rootKey.id,
+                    receiverCipherData: initiatorContactCard
+                        ? JSON.stringify(yield this.encryptionService.encrypt(receiverKey, initiatorContactCard.receiverCipherDataClearJson))
+                        : '',
+                    sharedWrappedKey: JSON.stringify(yield this.encryptionService.encrypt(sharedKey, ccSharedKey.toJSON(true))),
+                };
+                const sharedCipherData = yield this.encryptionService.encrypt(ccSharedKey, sharedCipherDataClearJson);
+                receivedCardInput.sharedCipherDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, sharedCipherData));
+                receivedCardInput.sigPxkId = sigPxk.id;
+                initiatorOneTimePbkCipherClearJson.responder.contactCard = Object.assign(Object.assign({}, initiatorOneTimePbkCipherClearJson.responder.contactCard), { sharedCipherKey: ccSharedKey.toJSON(true) });
+            }
+            let responderCardInput;
+            if (responderContactCard) {
+                // Create keys
+                const ownerKey = yield this.keyFactory.createKey();
+                const ccSharedKey = yield this.keyFactory.createKey();
+                const sigPxk = this.keyService.currentSigPxk;
+                responderCardInput = {
+                    ownerWrappedKey: JSON.stringify(yield this.encryptionService.encrypt(rootKey.jwk, ownerKey.toJSON(true))),
+                    ownerWrappingKeyId: rootKey.id,
+                    ownerCipherData: responderContactCard.ownerCipherDataClearJson
+                        ? JSON.stringify(yield this.encryptionService.encrypt(ownerKey, responderContactCard.ownerCipherDataClearJson))
+                        : '',
+                    sharedWrappedKey: JSON.stringify(yield this.encryptionService.encrypt(sharedKey, ccSharedKey.toJSON(true))),
+                };
+                const sharedCipherData = yield this.encryptionService.encrypt(ccSharedKey, responderContactCard.sharedCipherDataClearJson);
+                responderCardInput.sharedCipherDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, sharedCipherData));
+                responderCardInput.sigPxkId = sigPxk.id;
+                if (responderContactCard.ownerPlainDataJson) {
+                    responderCardInput.ownerPlainDataSig = JSON.stringify(yield this.encryptionService.sign(responderSigPrk.jwk, responderContactCard.ownerPlainDataJson));
+                }
+                // Contact card info readable by the initiator
+                initiatorOneTimePbkCipherClearJson.responder.contactCard = Object.assign(Object.assign({}, initiatorOneTimePbkCipherClearJson.responder.contactCard), { sharedCipherDataClearJson: responderContactCard.sharedCipherDataClearJson });
+            }
+            // Encrypt with one-time public key
+            let initiatorOneTimePbkCipher = yield this.encryptionService.encrypt(initiatorOneTimePbk, initiatorOneTimePbkCipherClearJson);
+            // Encrypt with the otk again to keep use of asymmetric keys to a minimum.
+            initiatorOneTimePbkCipher = yield this.encryptionService.encrypt(decryptedOtk.otKey, initiatorOneTimePbkCipher);
+            return new LrMutation({
+                mutation: RespondKeyExchangeOtkMutation,
+                variables: {
+                    input: {
+                        keyExchangeId,
+                        keyExchangeToken: token,
+                        rootKeyId: rootKey.id,
+                        masterKeyId: masterKey.id,
+                        // These will be stored on the server
+                        responderPxkId: responderPrk.id,
+                        responderSigPxkId: responderSigPrk.id,
+                        signedInitiatorPbk: JSON.stringify(signedInitiatorPbk),
+                        signedInitiatorSigPbk: JSON.stringify(signedInitiatorSigPbk),
+                        // rkWrappedInitiatorSigPbk: JSON.stringify(rkWrappedInitiatorSigPbk),
+                        // Option 1: Using new Prk for each TP pair
+                        // rkWrappedResponderSigPrk: JSON.stringify(rkWrappedResponderSigPrk),
+                        rkWrappedSharedKey: JSON.stringify(rkWrappedSharedKey),
+                        mkWrappedMkSharedKey: JSON.stringify(mkWrappedMkSharedKey),
+                        // These will be sent to the initiator
+                        initiatorOneTimePbkCipher: JSON.stringify(initiatorOneTimePbkCipher),
+                        initiatorContactCard: receivedCardInput,
+                        responderContactCard: responderCardInput,
+                    },
+                },
+            });
+        });
+    }
+    completeOtk(input) {
+        return this.mutate(this.completeOtkMutation(input));
+    }
+    completeOtkMutation({ keyExchangeId, initiatorRootKeyCipher, initiatorOneTimePbkCipher, responderContactCard, initiatorContactCard, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rootKey = this.keyService.currentRootKey;
+            const masterKey = this.keyService.currentMasterKey;
+            // Decrypt using the root key to get the Prk
+            const initiatorRootKeyCipherClearJson = (yield this.encryptionService.decrypt(rootKey.jwk, initiatorRootKeyCipher));
+            // The Prk is single-use and only used to send information from the responder back to the initiator.
+            const plainInitiatorOneTimePbkCipher = yield this.decryptResponseCipher(yield KeyFactoryService.asKey(initiatorRootKeyCipherClearJson.otKey), yield KeyFactoryService.asKey(initiatorRootKeyCipherClearJson.oneTimePrk), initiatorOneTimePbkCipher);
+            // Check the nonce match to ensure the responder was the one holding the OTK
+            if (initiatorRootKeyCipherClearJson.nonce !==
+                plainInitiatorOneTimePbkCipher.nonce) {
+                throw new KcCodeMismatchException('The nonce returned by responder does not match with the one created by the initiator.');
+            }
+            // Option 1: Assuming the signing key is unique between users.
+            // const initiatorSigPrk = await KFS.asKey(ke.plainInitiatorRootKeyCipher.sigPrk);
+            // const rkWrappedInitiatorSigPrk = await this.encrypt(rootKey, initiatorSigPrk.toJSON(true));
+            // Option 2: Use the user's global signing key.
+            // In this case the initiatorSigPrk is already a part of the key graph.
+            // So there's nothing to do here.
+            // Protected the signing public key of the responder.
+            const initiatorSigPrk = this.keyService.currentSigPxk;
+            const responderSigPbk = yield KeyFactoryService.asKey(plainInitiatorOneTimePbkCipher.responder.sigPbk);
+            const responderPbk = yield KeyFactoryService.asKey(plainInitiatorOneTimePbkCipher.responder.pbk);
+            const signedResponderPbk = yield this.encryptionService.sign(initiatorSigPrk.jwk, responderPbk.toJSON());
+            const signedResponderSigPbk = yield this.encryptionService.sign(initiatorSigPrk.jwk, responderSigPbk.toJSON());
+            const sharedKey = yield KeyFactoryService.asKey(plainInitiatorOneTimePbkCipher.sharedKey);
+            const rkWrappedSharedKey = yield this.encryptionService.encrypt(rootKey.jwk, sharedKey.toJSON(true));
+            const mkSharedKey = yield KeyFactoryService.asKey(plainInitiatorOneTimePbkCipher.mkSharedKey);
+            const mkWrappedMkSharedKey = yield this.encryptionService.encrypt(masterKey.jwk, mkSharedKey.toJSON(true));
+            let responderContactCardCipherInput;
+            if (responderContactCard) {
+                // Create key
+                const receiverKey = yield this.keyFactory.createKey();
+                responderContactCardCipherInput = {
+                    receiverWrappedKey: JSON.stringify(yield this.encryptionService.encrypt(rootKey.jwk, receiverKey.toJSON(true))),
+                    receiverWrappingKeyId: rootKey.id,
+                    receiverCipherData: JSON.stringify(yield this.encryptionService.encrypt(receiverKey, responderContactCard.receiverCipherDataClearJson)),
+                };
+            }
+            // Get the data needed from the initiator's cipher data.
+            let initiatorContactCardCipherInput;
+            let initiatorContactCardSharedCipherInput;
+            if (initiatorRootKeyCipherClearJson.initiatorContactCard) {
+                // The initiatorContactCard created during the creation of the invite and encrypted using the initiator's
+                // root key
+                const initiatorContactCardFromInit = initiatorRootKeyCipherClearJson.initiatorContactCard;
+                const ownerKey = yield this.keyFactory.createKey();
+                const sharedCipherKey = yield KeyFactoryService.asKey(plainInitiatorOneTimePbkCipher.responder.contactCard.sharedCipherKey);
+                const ownerWrappedKey = JSON.stringify(yield this.encryptionService.encrypt(rootKey.jwk, ownerKey.toJSON(true)));
+                // Allow the initiatorContactCard parameter to override
+                const ownerCipherDataClearJson = (initiatorContactCard === null || initiatorContactCard === void 0 ? void 0 : initiatorContactCard.ownerCipherDataClearJson) ||
+                    initiatorContactCardFromInit.ownerCipherDataClearJson;
+                const ownerCipherData = ownerCipherDataClearJson
+                    ? yield this.keyGraph.encryptToString(ownerKey, ownerCipherDataClearJson)
+                    : '';
+                initiatorContactCardCipherInput = {
+                    ownerWrappedKey,
+                    ownerWrappingKeyId: rootKey.id,
+                    ownerCipherData,
+                };
+                initiatorContactCardSharedCipherInput = {
+                    sigPxkId: initiatorSigPrk.id,
+                };
+                const sharedCipherData = yield this.encryptionService.encrypt(sharedCipherKey, initiatorContactCardFromInit.sharedCipherDataClearJson);
+                initiatorContactCardSharedCipherInput.sharedCipherDataSig =
+                    JSON.stringify(yield this.encryptionService.sign(initiatorSigPrk.jwk, sharedCipherData));
+            }
+            // TODO ideally we update the shared data in the contact card sent to the responder as well since that
+            // CC was created by the responder.
+            return new LrMutation({
+                mutation: CompleteKeyExchangeOtkMutation,
+                variables: {
+                    input: {
+                        keyExchangeId,
+                        rootKeyId: rootKey.id,
+                        masterKeyId: masterKey.id,
+                        initiatorSigPxkId: initiatorSigPrk.id,
+                        signedResponderPbk: JSON.stringify(signedResponderPbk),
+                        signedResponderSigPbk: JSON.stringify(signedResponderSigPbk),
+                        rkWrappedSharedKey: JSON.stringify(rkWrappedSharedKey),
+                        mkWrappedMkSharedKey: JSON.stringify(mkWrappedMkSharedKey),
+                        responderContactCardCipher: responderContactCardCipherInput,
+                        initiatorContactCardCipher: initiatorContactCardCipherInput,
+                        initiatorContactCardSharedCipher: initiatorContactCardSharedCipherInput,
+                    },
+                },
+            });
+        });
+    }
+};
+KeyExchangeService.ɵprov = i0.ɵɵdefineInjectable({ factory: function KeyExchangeService_Factory() { return new KeyExchangeService(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i1.KeyFactoryService), i0.ɵɵinject(i2.KeyService), i0.ɵɵinject(i3.EncryptionService), i0.ɵɵinject(i4.KeyGraphService)); }, token: KeyExchangeService, providedIn: "root" });
+KeyExchangeService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+KeyExchangeService.ctorParameters = () => [
+    { type: NgZone },
+    { type: Injector },
+    { type: KeyFactoryService },
+    { type: KeyService },
+    { type: EncryptionService },
+    { type: KeyGraphService }
+];
+KeyExchangeService = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], KeyExchangeService);
+export { KeyExchangeService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-exchange.service.js","sourceRoot":"","sources":["../../../../../../projects/core/src/lib/key-exchange/key-exchange.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, NgZone } from '@angular/core';\nimport { JWK } from 'node-jose';\nimport { LrMutation, LrService } from '../api/lr-graphql';\nimport {\n  ContactCardSharedCipherData,\n  JSONObject,\n  OtKeyCipherClearJson2,\n} from '../api/types';\nimport { OwnerPlainDataJson } from '../contact-card/contact-card2.service';\nimport {\n  EncryptionService,\n  JoseSerialization,\n} from '../encryption/encryption.service';\nimport { KeyFactoryService } from '../key/key-factory.service';\nimport { KeyGraphService } from '../key/key-graph.service';\nimport { KeyService } from '../key/key.service';\nimport { KcCodeMismatchException } from '../_common/exceptions';\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\nimport {\n  CancelKeyExchangeMutation,\n  CompleteKeyExchangeOtkMutation,\n  CurrentUserSharedKeyQuery2,\n  DeclineKeyExchangeMutation,\n  InitiateKeyExchangeOtkMutation,\n  KeyExchangeFieldsResult,\n  KeyExchangeQuery2,\n  KeyExchangesQuery2,\n  KeyExchangeState2,\n  KeyExchangeTokenQuery2,\n  RespondKeyExchangeOtkMutation,\n} from './key-exchange.gql';\n\n/**\n * The decrypted content of the one-time key cipher;\n * When user supplies this information the lib doesn't need to do another API call\n * to fetch the key exchange node. And since the typical use case is to display\n * some information to the user, the key exchange node would already have been\n * fetched and decrypted.\n */\nexport interface DecryptedOtk2 {\n  otKeyCipherClearJson: OtKeyCipherClearJson2;\n  otKey: JWK.Key; // The one-time key\n}\n\nexport interface ContactCardReceiverCipherData {\n  // The receiver of the contact card keeps a copy\n  // of the owner's contact card information, encrypted using the receiver's keys. So that when\n  // the owner decides to update their shared contact card at a later date, the receiver can\n  // compare against the original contact card sent during key exchange. This way, the owner\n  // can't unilaterally update their shared contact card without the receiver knowing about it.\n  receiverCipherDataClearJson: JSONObject;\n}\n\nexport interface ContactCardOwnerPlainData {\n  // Accessible by the server and the owner. Server side notification emails need to know some\n  // information about the owner.\n  // The owner could either be the initiator or the responder.\n  ownerPlainDataJson: OwnerPlainDataJson;\n}\n\nexport interface ContactCardOwnerCipherData {\n  // Owner only access to this data\n  ownerCipherDataClearJson: JSONObject;\n}\n\n/**\n * Sending contact card information from the owner to the receiver.\n */\nexport type SendContactCardInput = ContactCardOwnerPlainData &\n  ContactCardOwnerCipherData &\n  ContactCardSharedCipherData;\n\nexport interface InitiateOtkInput2 {\n  // Note that if neither email nor responderUsername are given, the one-time key\n  // can still be sent to the responder via OOB\n  email?: string;\n  message?: JSONObject;\n  contactCard?: SendContactCardInput;\n  // If True, to upgrade an email invite to an existing user invite if the email\n  // is already associated with an existing user.\n  upgrade?: boolean;\n}\n\nexport interface RespondOtkInput2 {\n  keyExchangeId: string;\n  token: string;\n  decryptedOtk: DecryptedOtk2;\n  message?: JSONObject;\n  // The initiator is the owner fo the initiatorContactCard, the responder\n  // is the receiver.\n  initiatorContactCard?: ContactCardReceiverCipherData;\n  responderContactCard?: SendContactCardInput;\n}\n\nexport interface CompleteOtkInput2 {\n  keyExchangeId: string;\n  // This is a part of the key exchange data. It's encrypted using the root key\n  initiatorRootKeyCipher: string;\n  // This is a part of the key exchange data. It's encrypted using the one-time key.\n  initiatorOneTimePbkCipher: string;\n  // The responder is the owner fo the responderContactCard, the initiator\n  // is the receiver.\n  responderContactCard?: ContactCardReceiverCipherData;\n  // The initiator can update the cipher data that are only visible to them. It makes\n  // less sense to update the shared data because the responder would have already seen\n  // the shared data and accepted that it's legit.\n  // But in any case, the initiator can update the shared contact card info at any time.\n  initiatorContactCard?: ContactCardOwnerCipherData;\n}\n\nexport interface InitiatorRootKeyCipherClearJson2 {\n  nonce: string;\n  oneTimePrk: Record<string, JSONObject>; // one-time public encryption key responder use to send data back to initiator\n  otKey: Record<string, JSONObject>; // one-time symmetric key that needs to be shared OOB\n  initiatorContactCard?: ContactCardOwnerCipherData &\n    ContactCardSharedCipherData;\n  initiator: {\n    message?: JSONObject;\n    contactCard?: ContactCardSharedCipherData;\n  };\n}\n\nexport interface InitiatorOneTimePbkCipherClearJson {\n  nonce: string;\n  sharedKey: Record<string, JSONObject>;\n  mkSharedKey: Record<string, JSONObject>;\n  responder: {\n    pbk: Record<string, JSONObject>;\n    sigPbk: Record<string, JSONObject>;\n    message?: JSONObject;\n    contactCard?: ContactCardSharedCipherData & {\n      // Note that this is _not_ the same key as the sharedKey. The sharedKey wraps\n      // this key in the key graph. But because this key has not been entered into\n      // the key graph when the responder calls the API, we pass the JWK directly here.\n      sharedCipherKey: Record<string, JSONObject>;\n    };\n  };\n}\n\nexport interface GetKeyExchangeOptions2 {\n  // The otKey as a raw string. i.e. key.toJSON(true).k\n  otKeyK?: string;\n  // User need the token if they have not responded to the key exchange yet.\n  // Once they've responded (hence proven they have the OOB Key) they become\n  // the \"responder\" of this exchange, and can access it when signed in.\n  token?: string;\n}\n\n@RunOutsideAngular({\n  ngZoneName: 'ngZone',\n})\n@Injectable({\n  providedIn: 'root',\n})\nexport class KeyExchangeService extends LrService {\n  private readonly CLIENT_NONCE_LENGTH = 32;\n\n  constructor(\n    private ngZone: NgZone,\n    private injector: Injector,\n    private keyFactory: KeyFactoryService,\n    private keyService: KeyService,\n    private encryptionService: EncryptionService,\n    private keyGraph: KeyGraphService\n  ) {\n    super(injector);\n  }\n\n  private async getOtKey(\n    keyExchange: KeyExchangeFieldsResult,\n    otKeyK?: string\n  ): Promise<JWK.Key> {\n    if (otKeyK) {\n      return await KeyFactoryService.asKey({\n        ...JSON.parse(keyExchange.otk.otKeyParams),\n        k: otKeyK,\n      });\n    } else if (\n      keyExchange.otk.state === 'OTK_INITIATED' &&\n      !keyExchange.isInitiator &&\n      keyExchange.otk.responderPbkCipher\n    ) {\n      // Assuming existing user getting invited where OTK is wrapped in responder's public key.\n      const prk = this.keyService.currentPxk;\n      const decryptedCipher = await this.encryptionService.decrypt(\n        prk.jwk,\n        JSON.parse(keyExchange.otk.responderPbkCipher),\n        {\n          serializations: [JoseSerialization.COMPACT],\n        }\n      );\n      if (decryptedCipher.otKey) {\n        return await KeyFactoryService.asKey(decryptedCipher.otKey);\n      }\n    }\n    return null;\n  }\n\n  private async decryptOtk(\n    keyExchange: KeyExchangeFieldsResult,\n    otKeyK?: string\n  ): Promise<KeyExchangeFieldsResult> {\n    const otKey = await this.getOtKey(keyExchange, otKeyK);\n\n    let otk = keyExchange.otk;\n\n    if (otKey && otk.otKeyCipher) {\n      otk = {\n        ...otk,\n        otKey,\n        otKeyCipherClearJson: await this.encryptionService.decrypt(\n          otKey,\n          keyExchange.otk.otKeyCipher\n        ),\n      };\n    }\n\n    return {\n      ...keyExchange,\n      otk,\n    };\n  }\n\n  private async decryptResponseCipher(\n    otKey: JWK.Key,\n    otPrk: JWK.Key,\n    content: JSONObject\n  ): Promise<InitiatorOneTimePbkCipherClearJson> {\n    // The response could be wrapped by the OtK in addition to the OtPbk\n    try {\n      content = await this.encryptionService.decrypt(otKey, content);\n    } catch (error) {\n      if (error.message !== 'no key found') {\n        throw error;\n      }\n      // Do nothing to support older versions where message is not wrapped with otk.\n    }\n\n    // The Prk is single-use and only used to send information from the responder back to the initiator.\n    return await this.encryptionService.decrypt(otPrk, content);\n  }\n\n  private async decryptKeyExchangeAsInitiator(\n    keyExchange: KeyExchangeFieldsResult\n  ): Promise<KeyExchangeFieldsResult> {\n    const rootKey = this.keyService.currentRootKey;\n\n    // Decrypt using the root key to get the Prk\n    const initiatorRootKeyCipherClearJson =\n      (await this.encryptionService.decrypt(\n        rootKey.jwk,\n        keyExchange.initiatorRootKeyCipher\n      )) as InitiatorRootKeyCipherClearJson2;\n\n    const otKey = await KeyFactoryService.asKey(\n      initiatorRootKeyCipherClearJson.otKey\n    );\n\n    keyExchange = {\n      ...keyExchange,\n      initiatorRootKeyCipherClearJson,\n    };\n\n    let otk = keyExchange.otk;\n\n    if (otk.initiatorOneTimePbkCipher) {\n      otk = {\n        ...otk,\n        initiatorOneTimePbkCipherClearJson: await this.decryptResponseCipher(\n          otKey,\n          await KeyFactoryService.asKey(\n            initiatorRootKeyCipherClearJson.oneTimePrk\n          ),\n          otk.initiatorOneTimePbkCipher\n        ),\n      };\n    }\n\n    if (otk.otKeyCipher) {\n      otk.otKeyCipherClearJson = await this.encryptionService.decrypt(\n        otKey,\n        otk.otKeyCipher\n      );\n    }\n\n    return {\n      ...keyExchange,\n      otk,\n    };\n  }\n\n  private async decryptKeyExchangeAsResponder(\n    keyExchange: KeyExchangeFieldsResult,\n    otKeyK?: string\n  ) {\n    return this.decryptOtk(keyExchange, otKeyK);\n  }\n\n  async decryptKeyExchange(\n    keyExchange: KeyExchangeFieldsResult,\n    otKeyK?: string\n  ) {\n    if (keyExchange.isInitiator) {\n      return this.decryptKeyExchangeAsInitiator(keyExchange);\n    } else {\n      return this.decryptKeyExchangeAsResponder(keyExchange, otKeyK);\n    }\n  }\n\n  async getKeyExchanges({ state }: { state?: KeyExchangeState2 } = {}) {\n    const { keyExchanges } = await this.query({\n      query: KeyExchangesQuery2,\n      variables: {\n        state,\n      },\n    });\n\n    return Promise.all(\n      keyExchanges.edges.map((edge) => this.decryptKeyExchange(edge.node))\n    );\n  }\n\n  /**\n   * @param id If the current user can responder the key exchange if they are either the initiator or the receiver.\n   * @param token If not signed in, or not the initiator or responder, 'token' must be given.\n   * @param otKeyK Is the raw one-time key (string). If the responder is explicitly specified at time of initiation, then\n   *   it's possible to have the otKey wrapped by the public key of the responder. In which case, the otKeyK is not needed.\n   */\n  async getKeyExchange(\n    id: string,\n    { otKeyK, token }: GetKeyExchangeOptions2 = {}\n  ) {\n    const res = await this.query({\n      query: token ? KeyExchangeTokenQuery2 : KeyExchangeQuery2,\n      variables: {\n        id,\n        token,\n      },\n      includeKeyGraph: !token, // if !token then we are post auth, so can fetch keyGraph\n    });\n    return this.decryptKeyExchange(res.keyExchange, otKeyK);\n  }\n\n  public async getCurrentUserSharedKey(input: {\n    username?: string;\n    userId?: string;\n  }) {\n    return this.query({\n      query: CurrentUserSharedKeyQuery2,\n      variables: {\n        username: input.username,\n        userId: input.userId,\n      },\n    });\n  }\n\n  cancelKeyExchange(id: string) {\n    return this.mutate(this.cancelKeyExchangeMutation(id));\n  }\n\n  cancelKeyExchangeMutation(id: string) {\n    return new LrMutation({\n      mutation: CancelKeyExchangeMutation,\n      variables: {\n        input: {\n          id,\n        },\n      },\n    });\n  }\n\n  declineKeyExchange(id: string, token: string) {\n    return this.mutate(this.declineKeyExchangeMutation(id, token));\n  }\n\n  declineKeyExchangeMutation(id: string, token: string) {\n    return new LrMutation({\n      mutation: DeclineKeyExchangeMutation,\n      variables: {\n        input: {\n          id,\n          token,\n        },\n      },\n    });\n  }\n\n  async initiateOtk(input: InitiateOtkInput2 = {}) {\n    return this.mutate((await this.initiateOtkMutation(input)).lrMutation);\n  }\n\n  async initiateOtkMutation({\n    message,\n    email,\n    contactCard,\n    upgrade,\n  }: InitiateOtkInput2 = {}) {\n    const otKey = await this.keyFactory.createKey();\n    const nonce = this.keyFactory.randomString(this.CLIENT_NONCE_LENGTH);\n\n    // New PKC key for encryption. This key is used only once when the responder sends\n    // back their signing public key.\n    const initiatorOneTimePrk = await this.keyFactory.createPkcKey();\n\n    // Option 1: New PKC key for signing\n    // const initiatorSigPrk = await this.keyService.createPkcSignKey();\n\n    // Option 2: Use the user's global signing key.\n    // This key is used to prove the initiator's identity.\n    const initiatorPrk = this.keyService.currentPxk;\n    const initiatorSigPrk = this.keyService.currentSigPxk;\n\n    let initiatorPlainDataSig: string = null;\n\n    if (contactCard && contactCard.ownerPlainDataJson) {\n      initiatorPlainDataSig = await this.encryptionService.signToString(\n        initiatorSigPrk.jwk,\n        contactCard.ownerPlainDataJson\n      );\n    }\n\n    const initiator = {\n      message,\n      contactCard: contactCard && {\n        sharedCipherDataClearJson: contactCard.sharedCipherDataClearJson,\n      },\n    };\n\n    // Content to be encrypted using the OTK.\n    const plainOtKeyCipher: OtKeyCipherClearJson2 = {\n      // TODO Make sure we also put the OOB code in here as well since the OOB code is the\n      // _only_ information the KC server does not have access to. The server may have\n      // access to OTK and hence the nonce here. It's good to have both the nonce and OOB code\n      // since the user may not be using the OOB code. And it's simple to always include\n      // the nonce, so why not.\n      nonce,\n      initiator: {\n        ...initiator,\n        oneTimePbk: initiatorOneTimePrk.toJSON(), // one-time public encryption key responder use to send data back to initiator\n        pbk: initiatorPrk.jwk.toJSON(), // public encryption key\n        sigPbk: initiatorSigPrk.jwk.toJSON(), // public signing key\n      },\n    };\n\n    const otKeyCipher = await this.keyGraph.encryptToString(\n      otKey,\n      plainOtKeyCipher\n    );\n\n    // Content to be encrypted using the initiator's root key.\n    const initiatorRootKeyCipherClearJson: InitiatorRootKeyCipherClearJson2 = {\n      nonce,\n      oneTimePrk: initiatorOneTimePrk.toJSON(true),\n      // Should not need to keep this encrypted since we are using the global signing key.\n      // sigPrk: initiatorSigPrk.toJSON(true),\n\n      // Save it in case the initiator want to decode the otKeyCipher.\n      // Since the otKey is only used once, and that otKeyCipher contains only\n      // the public key of the initiator, it's safe just leave the otKey stored here.\n      otKey: otKey.toJSON(true),\n      // These should be storing information such as how the fields of the shared contact card is\n      // derived from the master contact card.\n      initiatorContactCard: contactCard,\n      initiator,\n    };\n\n    const rootKey = this.keyService.currentRootKey;\n    const initiatorRootKeyCipher = await this.keyGraph.encryptToString(\n      rootKey.jwk,\n      initiatorRootKeyCipherClearJson\n    );\n\n    // The raw OTK\n    const otKeyK: string = (otKey.toJSON(true) as JSONObject).k;\n\n    // API call\n    const lrMutation = new LrMutation({\n      mutation: InitiateKeyExchangeOtkMutation,\n      variables: {\n        input: {\n          // These will be stored on the server\n          initiatorRootKeyCipher,\n          initiatorPxkId: initiatorPrk.id,\n          initiatorSigPxkId: initiatorSigPrk.id,\n          // These will be sent to the responder\n          otKeyParams: JSON.stringify(otKey.toJSON()),\n          otKeyCipher,\n          sendEmail: email && {\n            email,\n            rawOtKey: otKeyK,\n          },\n          createTp: true,\n          initiatorPlainDataSig,\n          upgrade,\n        },\n      },\n    });\n\n    return { lrMutation, otKeyK };\n  }\n\n  respondOtk(input: RespondOtkInput2) {\n    return this.mutate(this.respondOtkMutation(input));\n  }\n\n  async respondOtkMutation({\n    keyExchangeId,\n    token,\n    decryptedOtk,\n    message,\n    initiatorContactCard,\n    responderContactCard,\n  }: RespondOtkInput2) {\n    const rootKey = this.keyService.currentRootKey;\n\n    const masterKey = this.keyService.currentMasterKey;\n\n    const sharedKey = await this.keyFactory.createKey();\n    const mkSharedKey = await this.keyFactory.createKey();\n\n    const rkWrappedSharedKey = await this.encryptionService.encrypt(\n      rootKey.jwk,\n      sharedKey.toJSON(true)\n    );\n    const mkWrappedMkSharedKey = await this.encryptionService.encrypt(\n      masterKey.jwk,\n      mkSharedKey.toJSON(true)\n    );\n\n    const initiatorOneTimePbk = await KeyFactoryService.asKey(\n      decryptedOtk.otKeyCipherClearJson.initiator.oneTimePbk\n    );\n\n    const initiatorPbk = await KeyFactoryService.asKey(\n      decryptedOtk.otKeyCipherClearJson.initiator.pbk\n    );\n    const initiatorSigPbk = await KeyFactoryService.asKey(\n      decryptedOtk.otKeyCipherClearJson.initiator.sigPbk\n    );\n\n    // Option 1: Using new Prk for each TP pair\n    // Create a new public signing key for the responder.\n    // const responderSigPrk = await this.keyService.createPkcSignKey()\n    // const rkWrappedResponderSigPrk = await this.encrypt(rootKey, responderSigPrk.toJSON(true));\n\n    // Option 2: Responder already has a signing Prk\n    const responderPrk = this.keyService.currentPxk;\n    const responderSigPrk = this.keyService.currentSigPxk;\n\n    const signedInitiatorPbk = await this.encryptionService.sign(\n      responderSigPrk.jwk,\n      initiatorPbk.toJSON()\n    );\n    const signedInitiatorSigPbk = await this.encryptionService.sign(\n      responderSigPrk.jwk,\n      initiatorSigPbk.toJSON()\n    );\n\n    const initiatorOneTimePbkCipherClearJson: InitiatorOneTimePbkCipherClearJson =\n      {\n        nonce: decryptedOtk.otKeyCipherClearJson.nonce,\n        sharedKey: sharedKey.toJSON(true),\n        mkSharedKey: mkSharedKey.toJSON(true),\n        responder: {\n          pbk: responderPrk.jwk.toJSON(), // public key\n          sigPbk: responderSigPrk.jwk.toJSON(), // public key\n          message,\n        },\n      };\n\n    let receivedCardInput;\n    if (decryptedOtk.otKeyCipherClearJson.initiator.contactCard) {\n      // Set the info about the initiator to be the ones sent by the initiator. We need th responder to do the encryption here\n      // because the initiator does not have the shared key yet, and we want the responder to have a functional contact card after\n      // this exchange. The initiator can double check the contact details are correct and sign it when it completes the exchange.\n      const sharedCipherDataClearJson =\n        decryptedOtk.otKeyCipherClearJson.initiator.contactCard\n          .sharedCipherDataClearJson;\n\n      // Create keys\n      const receiverKey = await this.keyFactory.createKey();\n      const ccSharedKey = await this.keyFactory.createKey();\n      const sigPxk = this.keyService.currentSigPxk;\n\n      receivedCardInput = {\n        receiverWrappedKey: JSON.stringify(\n          await this.encryptionService.encrypt(\n            rootKey.jwk,\n            receiverKey.toJSON(true)\n          )\n        ),\n        receiverWrappingKeyId: rootKey.id,\n        receiverCipherData: initiatorContactCard\n          ? JSON.stringify(\n              await this.encryptionService.encrypt(\n                receiverKey,\n                initiatorContactCard.receiverCipherDataClearJson\n              )\n            )\n          : '',\n        sharedWrappedKey: JSON.stringify(\n          await this.encryptionService.encrypt(\n            sharedKey,\n            ccSharedKey.toJSON(true)\n          )\n        ),\n      };\n\n      const sharedCipherData = await this.encryptionService.encrypt(\n        ccSharedKey,\n        sharedCipherDataClearJson\n      );\n      receivedCardInput.sharedCipherDataSig = JSON.stringify(\n        await this.encryptionService.sign(sigPxk.jwk, sharedCipherData)\n      );\n      receivedCardInput.sigPxkId = sigPxk.id;\n\n      initiatorOneTimePbkCipherClearJson.responder.contactCard = {\n        ...initiatorOneTimePbkCipherClearJson.responder.contactCard,\n        sharedCipherKey: ccSharedKey.toJSON(true),\n      };\n    }\n\n    let responderCardInput;\n    if (responderContactCard) {\n      // Create keys\n      const ownerKey = await this.keyFactory.createKey();\n      const ccSharedKey = await this.keyFactory.createKey();\n      const sigPxk = this.keyService.currentSigPxk;\n\n      responderCardInput = {\n        ownerWrappedKey: JSON.stringify(\n          await this.encryptionService.encrypt(\n            rootKey.jwk,\n            ownerKey.toJSON(true)\n          )\n        ),\n        ownerWrappingKeyId: rootKey.id,\n        ownerCipherData: responderContactCard.ownerCipherDataClearJson\n          ? JSON.stringify(\n              await this.encryptionService.encrypt(\n                ownerKey,\n                responderContactCard.ownerCipherDataClearJson\n              )\n            )\n          : '',\n\n        sharedWrappedKey: JSON.stringify(\n          await this.encryptionService.encrypt(\n            sharedKey,\n            ccSharedKey.toJSON(true)\n          )\n        ),\n      };\n\n      const sharedCipherData = await this.encryptionService.encrypt(\n        ccSharedKey,\n        responderContactCard.sharedCipherDataClearJson\n      );\n      responderCardInput.sharedCipherDataSig = JSON.stringify(\n        await this.encryptionService.sign(sigPxk.jwk, sharedCipherData)\n      );\n      responderCardInput.sigPxkId = sigPxk.id;\n\n      if (responderContactCard.ownerPlainDataJson) {\n        responderCardInput.ownerPlainDataSig = JSON.stringify(\n          await this.encryptionService.sign(\n            responderSigPrk.jwk,\n            responderContactCard.ownerPlainDataJson\n          )\n        );\n      }\n\n      // Contact card info readable by the initiator\n      initiatorOneTimePbkCipherClearJson.responder.contactCard = {\n        ...initiatorOneTimePbkCipherClearJson.responder.contactCard,\n        sharedCipherDataClearJson:\n          responderContactCard.sharedCipherDataClearJson,\n      };\n    }\n\n    // Encrypt with one-time public key\n    let initiatorOneTimePbkCipher = await this.encryptionService.encrypt(\n      initiatorOneTimePbk,\n      initiatorOneTimePbkCipherClearJson\n    );\n\n    // Encrypt with the otk again to keep use of asymmetric keys to a minimum.\n    initiatorOneTimePbkCipher = await this.encryptionService.encrypt(\n      decryptedOtk.otKey,\n      initiatorOneTimePbkCipher\n    );\n\n    return new LrMutation({\n      mutation: RespondKeyExchangeOtkMutation,\n      variables: {\n        input: {\n          keyExchangeId,\n          keyExchangeToken: token,\n          rootKeyId: rootKey.id,\n          masterKeyId: masterKey.id,\n          // These will be stored on the server\n          responderPxkId: responderPrk.id,\n          responderSigPxkId: responderSigPrk.id,\n          signedInitiatorPbk: JSON.stringify(signedInitiatorPbk),\n          signedInitiatorSigPbk: JSON.stringify(signedInitiatorSigPbk),\n          // rkWrappedInitiatorSigPbk: JSON.stringify(rkWrappedInitiatorSigPbk),\n\n          // Option 1: Using new Prk for each TP pair\n          // rkWrappedResponderSigPrk: JSON.stringify(rkWrappedResponderSigPrk),\n          rkWrappedSharedKey: JSON.stringify(rkWrappedSharedKey),\n          mkWrappedMkSharedKey: JSON.stringify(mkWrappedMkSharedKey),\n          // These will be sent to the initiator\n          initiatorOneTimePbkCipher: JSON.stringify(initiatorOneTimePbkCipher),\n          initiatorContactCard: receivedCardInput,\n          responderContactCard: responderCardInput,\n        },\n      },\n    });\n  }\n\n  completeOtk(input: CompleteOtkInput2) {\n    return this.mutate(this.completeOtkMutation(input));\n  }\n\n  async completeOtkMutation({\n    keyExchangeId,\n    initiatorRootKeyCipher,\n    initiatorOneTimePbkCipher,\n    responderContactCard,\n    initiatorContactCard,\n  }: CompleteOtkInput2) {\n    const rootKey = this.keyService.currentRootKey;\n    const masterKey = this.keyService.currentMasterKey;\n\n    // Decrypt using the root key to get the Prk\n    const initiatorRootKeyCipherClearJson =\n      (await this.encryptionService.decrypt(\n        rootKey.jwk,\n        initiatorRootKeyCipher\n      )) as InitiatorRootKeyCipherClearJson2;\n\n    // The Prk is single-use and only used to send information from the responder back to the initiator.\n    const plainInitiatorOneTimePbkCipher = await this.decryptResponseCipher(\n      await KeyFactoryService.asKey(initiatorRootKeyCipherClearJson.otKey),\n      await KeyFactoryService.asKey(initiatorRootKeyCipherClearJson.oneTimePrk),\n      initiatorOneTimePbkCipher\n    );\n\n    // Check the nonce match to ensure the responder was the one holding the OTK\n    if (\n      initiatorRootKeyCipherClearJson.nonce !==\n      plainInitiatorOneTimePbkCipher.nonce\n    ) {\n      throw new KcCodeMismatchException(\n        'The nonce returned by responder does not match with the one created by the initiator.'\n      );\n    }\n\n    // Option 1: Assuming the signing key is unique between users.\n    // const initiatorSigPrk = await KFS.asKey(ke.plainInitiatorRootKeyCipher.sigPrk);\n    // const rkWrappedInitiatorSigPrk = await this.encrypt(rootKey, initiatorSigPrk.toJSON(true));\n\n    // Option 2: Use the user's global signing key.\n    // In this case the initiatorSigPrk is already a part of the key graph.\n    // So there's nothing to do here.\n\n    // Protected the signing public key of the responder.\n    const initiatorSigPrk = this.keyService.currentSigPxk;\n    const responderSigPbk = await KeyFactoryService.asKey(\n      plainInitiatorOneTimePbkCipher.responder.sigPbk\n    );\n    const responderPbk = await KeyFactoryService.asKey(\n      plainInitiatorOneTimePbkCipher.responder.pbk\n    );\n\n    const signedResponderPbk = await this.encryptionService.sign(\n      initiatorSigPrk.jwk,\n      responderPbk.toJSON()\n    );\n    const signedResponderSigPbk = await this.encryptionService.sign(\n      initiatorSigPrk.jwk,\n      responderSigPbk.toJSON()\n    );\n\n    const sharedKey = await KeyFactoryService.asKey(\n      plainInitiatorOneTimePbkCipher.sharedKey\n    );\n    const rkWrappedSharedKey = await this.encryptionService.encrypt(\n      rootKey.jwk,\n      sharedKey.toJSON(true)\n    );\n\n    const mkSharedKey = await KeyFactoryService.asKey(\n      plainInitiatorOneTimePbkCipher.mkSharedKey\n    );\n    const mkWrappedMkSharedKey = await this.encryptionService.encrypt(\n      masterKey.jwk,\n      mkSharedKey.toJSON(true)\n    );\n\n    let responderContactCardCipherInput;\n    if (responderContactCard) {\n      // Create key\n      const receiverKey = await this.keyFactory.createKey();\n\n      responderContactCardCipherInput = {\n        receiverWrappedKey: JSON.stringify(\n          await this.encryptionService.encrypt(\n            rootKey.jwk,\n            receiverKey.toJSON(true)\n          )\n        ),\n        receiverWrappingKeyId: rootKey.id,\n        receiverCipherData: JSON.stringify(\n          await this.encryptionService.encrypt(\n            receiverKey,\n            responderContactCard.receiverCipherDataClearJson\n          )\n        ),\n      };\n    }\n\n    // Get the data needed from the initiator's cipher data.\n    let initiatorContactCardCipherInput;\n    let initiatorContactCardSharedCipherInput;\n    if (initiatorRootKeyCipherClearJson.initiatorContactCard) {\n      // The initiatorContactCard created during the creation of the invite and encrypted using the initiator's\n      // root key\n      const initiatorContactCardFromInit =\n        initiatorRootKeyCipherClearJson.initiatorContactCard;\n      const ownerKey = await this.keyFactory.createKey();\n      const sharedCipherKey = await KeyFactoryService.asKey(\n        plainInitiatorOneTimePbkCipher.responder.contactCard.sharedCipherKey\n      );\n\n      const ownerWrappedKey = JSON.stringify(\n        await this.encryptionService.encrypt(rootKey.jwk, ownerKey.toJSON(true))\n      );\n\n      // Allow the initiatorContactCard parameter to override\n      const ownerCipherDataClearJson =\n        initiatorContactCard?.ownerCipherDataClearJson ||\n        initiatorContactCardFromInit.ownerCipherDataClearJson;\n\n      const ownerCipherData = ownerCipherDataClearJson\n        ? await this.keyGraph.encryptToString(\n            ownerKey,\n            ownerCipherDataClearJson\n          )\n        : '';\n\n      initiatorContactCardCipherInput = {\n        ownerWrappedKey,\n        ownerWrappingKeyId: rootKey.id,\n        ownerCipherData,\n      };\n\n      initiatorContactCardSharedCipherInput = {\n        sigPxkId: initiatorSigPrk.id,\n      };\n\n      const sharedCipherData = await this.encryptionService.encrypt(\n        sharedCipherKey,\n        initiatorContactCardFromInit.sharedCipherDataClearJson\n      );\n      initiatorContactCardSharedCipherInput.sharedCipherDataSig =\n        JSON.stringify(\n          await this.encryptionService.sign(\n            initiatorSigPrk.jwk,\n            sharedCipherData\n          )\n        );\n    }\n\n    // TODO ideally we update the shared data in the contact card sent to the responder as well since that\n    // CC was created by the responder.\n\n    return new LrMutation({\n      mutation: CompleteKeyExchangeOtkMutation,\n      variables: {\n        input: {\n          keyExchangeId,\n          rootKeyId: rootKey.id,\n          masterKeyId: masterKey.id,\n          initiatorSigPxkId: initiatorSigPrk.id,\n          signedResponderPbk: JSON.stringify(signedResponderPbk),\n          signedResponderSigPbk: JSON.stringify(signedResponderSigPbk),\n          rkWrappedSharedKey: JSON.stringify(rkWrappedSharedKey),\n          mkWrappedMkSharedKey: JSON.stringify(mkWrappedMkSharedKey),\n          responderContactCardCipher: responderContactCardCipherInput,\n          initiatorContactCardCipher: initiatorContactCardCipherInput,\n          initiatorContactCardSharedCipher:\n            initiatorContactCardSharedCipherInput,\n        },\n      },\n    });\n  }\n}\n"]}