@lifeready/core 0.6.0-beta.1

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

@@ -0,0 +1,442 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { EncryptionService, JoseSerialization, } from '../cryptography/encryption.service';
+import { KeyService } from '../cryptography/key.service';
+import { LrCodeMismatchException } from '../_common/exceptions';
+import { UserService } from './../users/user.service';
+import { CompleteOtkMutation, CurrentUserSharedKeyQuery, InitiateOtkMutation, KeyExchangeQuery, KeyExchangesQuery, KeyExchangeTokenQuery, RespondOtkMutation, } from './key-exchange.gql';
+import { OtkState, } from './key-exchange.types';
+import { LrApolloService } from './lr-apollo.service';
+import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
+// Ref: https://stackoverflow.com/questions/59735280/angular-8-moment-error-cannot-call-a-namespace-moment
+import * as moment_ from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "../cryptography/key-factory.service";
+import * as i2 from "../cryptography/key.service";
+import * as i3 from "./lr-apollo.service";
+import * as i4 from "../cryptography/encryption.service";
+import * as i5 from "../auth/life-ready-auth.service";
+import * as i6 from "../users/user.service";
+const moment = moment_;
+export class KeyExchangeService {
+    constructor(keyFactory, keyService, lrApollo, encryptionService, authService, userService) {
+        this.keyFactory = keyFactory;
+        this.keyService = keyService;
+        this.lrApollo = lrApollo;
+        this.encryptionService = encryptionService;
+        this.authService = authService;
+        this.userService = userService;
+        this.CLIENT_NONCE_LENGTH = 32;
+    }
+    getKeyExchangeList(input = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { keyExchanges } = yield this.lrApollo.query({
+                query: KeyExchangesQuery,
+                variables: Object.assign({}, input),
+            });
+            return keyExchanges;
+        });
+    }
+    /**
+     * @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 { keyExchange } = yield this.lrApollo.query({
+                query: token ? KeyExchangeTokenQuery : KeyExchangeQuery,
+                variables: {
+                    id,
+                    token,
+                },
+            });
+            return yield this.decryptKeyExchange(keyExchange, otKeyK);
+        });
+    }
+    decryptResponseCipher(otKey, otPrk, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // The response could be wrapped by the OtK as well as we the OtPrk
+            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);
+        });
+    }
+    decryptKeyExchange(keyExchange, otKeyK) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (keyExchange.isInitiator) {
+                const rootKey = yield this.keyService.getCurrentRootKey();
+                // Decrypt using the root key to get the Prk
+                const plainInitiatorRootKeyCipher = (yield this.encryptionService.decrypt(rootKey.jwk, keyExchange.initiatorRootKeyCipher));
+                const plainInitiatorOneTimePbkCipher = keyExchange.otk
+                    .initiatorOneTimePbkCipher
+                    ? yield this.decryptResponseCipher(yield KFS.asKey(plainInitiatorRootKeyCipher.otKey), yield KFS.asKey(plainInitiatorRootKeyCipher.oneTimePrk), keyExchange.otk.initiatorOneTimePbkCipher)
+                    : null;
+                const responder = plainInitiatorOneTimePbkCipher &&
+                    plainInitiatorOneTimePbkCipher.responder;
+                const initiator = plainInitiatorRootKeyCipher && plainInitiatorRootKeyCipher.initiator;
+                return Object.assign(Object.assign({}, keyExchange), { message: responder ? responder.message : null, contactCard: responder && responder.contactCard
+                        ? responder.contactCard.plainSharedCipherDataJson
+                        : null, myContactCard: initiator && initiator.contactCard
+                        ? initiator.contactCard.plainSharedCipherDataJson
+                        : null, myMessage: initiator && initiator.message });
+            }
+            else {
+                const decryptedOtk = yield this.decryptOtk(keyExchange, otKeyK);
+                const initiator = decryptedOtk && decryptedOtk.plainOtKeyCipher.initiator;
+                return Object.assign(Object.assign({}, keyExchange), { decryptedOtk, message: initiator && initiator.message, contactCard: initiator &&
+                        initiator.contactCard &&
+                        initiator.contactCard.plainSharedCipherDataJson });
+            }
+        });
+    }
+    decryptOtk(keyExchange, otKeyK) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const otKey = yield this.getOtKey(keyExchange, otKeyK);
+            return otKey && keyExchange.otk.otKeyCipher
+                ? {
+                    plainOtKeyCipher: yield this.encryptionService.decrypt(otKey, keyExchange.otk.otKeyCipher),
+                    otKey,
+                }
+                : null;
+        });
+    }
+    getOtKey(keyExchange, otKeyK) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (otKeyK) {
+                return yield KFS.asKey(Object.assign(Object.assign({}, JSON.parse(keyExchange.otk.otKeyParams)), { k: otKeyK }));
+            }
+            else if (keyExchange.otk.state === OtkState.OTK_INITIATED &&
+                !keyExchange.isInitiator &&
+                keyExchange.otk.responderPbkCipher) {
+                // Assuming existing user getting invited where OTK is wrapped in responder's public key.
+                const prk = yield this.keyService.getCurrentPxk();
+                const decryptedCipher = yield this.encryptionService.decrypt(prk.jwk, JSON.parse(keyExchange.otk.responderPbkCipher), {
+                    serializations: [JoseSerialization.COMPACT],
+                });
+                if (decryptedCipher.otKey) {
+                    return yield KFS.asKey(decryptedCipher.otKey);
+                }
+            }
+            return null;
+        });
+    }
+    initiateOtk({ 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);
+            const user = yield this.authService.getUser();
+            // 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 = yield this.keyService.getCurrentPxk();
+            const initiatorSigPrk = yield this.keyService.getCurrentSigPxk();
+            let initiatorPlainDataSig = null;
+            if (contactCard && contactCard.ownerPlainData) {
+                initiatorPlainDataSig = JSON.stringify(yield this.encryptionService.sign(initiatorSigPrk.jwk, contactCard.ownerPlainData));
+            }
+            const initiator = {
+                message,
+                contactCard: contactCard
+                    ? {
+                        plainSharedCipherDataJson: contactCard.plainSharedCipherDataJson,
+                    }
+                    : null,
+            };
+            // Content to be encrypted using the OTK.
+            const plainOtKeyCipher = {
+                nonce,
+                initiator: Object.assign(Object.assign({}, initiator), { oneTimePbk: initiatorOneTimePrk.toJSON(), pbk: initiatorPrk.jwk.toJSON(), sigPbk: initiatorSigPrk.jwk.toJSON(), profile: {
+                        username: user.username,
+                    } }),
+            };
+            const otKeyCipher = yield this.encryptionService.encrypt(otKey, plainOtKeyCipher);
+            // Content to be encrypted using the initiator's root key.
+            const plainInitiatorRootKeyCipher = {
+                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 = yield this.keyService.getCurrentRootKey();
+            const initiatorRootKeyCipher = yield this.encryptionService.encrypt(rootKey.jwk, plainInitiatorRootKeyCipher);
+            // The raw OTK
+            const otKeyK = otKey.toJSON(true).k;
+            // API call
+            const { initiateKeyExchangeOtk } = yield this.lrApollo.mutate({
+                mutation: InitiateOtkMutation,
+                variables: {
+                    input: {
+                        // These will be stored on the server
+                        initiatorRootKeyCipher: JSON.stringify(initiatorRootKeyCipher),
+                        initiatorPxkId: initiatorPrk.id,
+                        initiatorSigPxkId: initiatorSigPrk.id,
+                        // These will be sent to the responder
+                        otKeyParams: JSON.stringify(otKey.toJSON()),
+                        otKeyCipher: JSON.stringify(otKeyCipher),
+                        sendEmail: email
+                            ? {
+                                email,
+                                rawOtKey: otKeyK,
+                            }
+                            : null,
+                        createTp: true,
+                        initiatorPlainDataSig,
+                        upgrade,
+                    },
+                },
+            });
+            return { keyExchange: initiateKeyExchangeOtk.keyExchange, otKeyK };
+        });
+    }
+    respondOtk({ id, token, decryptedOtk, message, initiatorContactCard, responderContactCard: sentContactCard, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.authService.getUser();
+            const rootKey = yield this.keyService.getCurrentRootKey();
+            const masterKeyId = this.keyService.getCurrentMasterKey().id;
+            const masterKey = yield this.keyService.getCurrentMasterKey();
+            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 KFS.asKey(decryptedOtk.plainOtKeyCipher.initiator.oneTimePbk);
+            const initiatorPbk = yield KFS.asKey(decryptedOtk.plainOtKeyCipher.initiator.pbk);
+            const initiatorSigPbk = yield KFS.asKey(decryptedOtk.plainOtKeyCipher.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 = yield this.keyService.getCurrentPxk();
+            const responderSigPrk = yield this.keyService.getCurrentSigPxk();
+            const signedInitiatorPbk = yield this.encryptionService.sign(responderSigPrk.jwk, initiatorPbk.toJSON());
+            const signedInitiatorSigPbk = yield this.encryptionService.sign(responderSigPrk.jwk, initiatorSigPbk.toJSON());
+            const plainInitiatorOneTimePbkCipher = {
+                nonce: decryptedOtk.plainOtKeyCipher.nonce,
+                sharedKey: sharedKey.toJSON(true),
+                mkSharedKey: mkSharedKey.toJSON(true),
+                responder: {
+                    pbk: responderPrk.jwk.toJSON(),
+                    sigPbk: responderSigPrk.jwk.toJSON(),
+                    profile: {
+                        username: user.username,
+                    },
+                    message,
+                },
+            };
+            let receivedCardInput;
+            if (decryptedOtk.plainOtKeyCipher.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 plainSharedCipherDataJson = decryptedOtk.plainOtKeyCipher.initiator.contactCard
+                    .plainSharedCipherDataJson;
+                // Create keys
+                const receiverKey = yield this.keyFactory.createKey();
+                const ccSharedKey = yield this.keyFactory.createKey();
+                const sigPxk = yield this.keyService.getCurrentSigPxk();
+                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.plainReceiverCipherDataJson))
+                        : '',
+                    sharedWrappedKey: JSON.stringify(yield this.encryptionService.encrypt(sharedKey, ccSharedKey.toJSON(true))),
+                };
+                const sharedCipherData = yield this.encryptionService.encrypt(ccSharedKey, plainSharedCipherDataJson);
+                receivedCardInput.sharedCipherDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, sharedCipherData));
+                receivedCardInput.sigPxkId = sigPxk.id;
+                plainInitiatorOneTimePbkCipher.responder.contactCard = Object.assign(Object.assign({}, plainInitiatorOneTimePbkCipher.responder.contactCard), { sharedCipherKey: ccSharedKey.toJSON(true) });
+            }
+            let sentCardInput;
+            if (sentContactCard) {
+                // Create keys
+                const ownerKey = yield this.keyFactory.createKey();
+                const ccSharedKey = yield this.keyFactory.createKey();
+                const sigPxk = yield this.keyService.getCurrentSigPxk();
+                sentCardInput = {
+                    ownerWrappedKey: JSON.stringify(yield this.encryptionService.encrypt(rootKey.jwk, ownerKey.toJSON(true))),
+                    ownerWrappingKeyId: rootKey.id,
+                    ownerCipherData: sentContactCard.plainOwnerCipherDataJson
+                        ? JSON.stringify(yield this.encryptionService.encrypt(ownerKey, sentContactCard.plainOwnerCipherDataJson))
+                        : '',
+                    sharedWrappedKey: JSON.stringify(yield this.encryptionService.encrypt(sharedKey, ccSharedKey.toJSON(true))),
+                };
+                const sharedCipherData = yield this.encryptionService.encrypt(ccSharedKey, sentContactCard.plainSharedCipherDataJson);
+                sentCardInput.sharedCipherDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, sharedCipherData));
+                sentCardInput.sigPxkId = sigPxk.id;
+                if (sentContactCard.ownerPlainData) {
+                    sentCardInput.ownerPlainDataSig = JSON.stringify(yield this.encryptionService.sign(responderSigPrk.jwk, sentContactCard.ownerPlainData));
+                }
+                // Contact card info readable by the initiator
+                plainInitiatorOneTimePbkCipher.responder.contactCard = Object.assign(Object.assign({}, plainInitiatorOneTimePbkCipher.responder.contactCard), { plainSharedCipherDataJson: sentContactCard.plainSharedCipherDataJson });
+            }
+            // Encrypt with one-time public key
+            let initiatorOneTimePbkCipher = yield this.encryptionService.encrypt(initiatorOneTimePbk, plainInitiatorOneTimePbkCipher);
+            // Encrypt with the otk again to keep use of asymmetric keys to a minimum.
+            initiatorOneTimePbkCipher = yield this.encryptionService.encrypt(decryptedOtk.otKey, initiatorOneTimePbkCipher);
+            const { respondKeyExchangeOtk } = yield this.lrApollo.mutate({
+                mutation: RespondOtkMutation,
+                variables: {
+                    input: {
+                        keyExchangeId: id,
+                        keyExchangeToken: token,
+                        rootKeyId: rootKey.id,
+                        masterKeyId,
+                        // 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: sentCardInput,
+                    },
+                },
+            });
+            return {
+                keyExchange: respondKeyExchangeOtk.keyExchange,
+                userSharedKey: respondKeyExchangeOtk.userSharedKey,
+                tp: respondKeyExchangeOtk.tp,
+            };
+        });
+    }
+    completeOtk(keyExchangeId, initiatorRootKeyCipher, initiatorOneTimePbkCipher, responderContactCard) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rootKey = yield this.keyService.getCurrentRootKey();
+            const masterKey = yield this.keyService.getCurrentMasterKey();
+            // Decrypt using the root key to get the Prk
+            const plainInitiatorRootKeyCipher = (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 KFS.asKey(plainInitiatorRootKeyCipher.otKey), yield KFS.asKey(plainInitiatorRootKeyCipher.oneTimePrk), initiatorOneTimePbkCipher);
+            // Check the nonce match to ensure the responder was the one holding the OTK
+            if (plainInitiatorRootKeyCipher.nonce !== plainInitiatorOneTimePbkCipher.nonce) {
+                throw new LrCodeMismatchException('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 = yield this.keyService.getCurrentSigPxk();
+            const responderSigPbk = yield KFS.asKey(plainInitiatorOneTimePbkCipher.responder.sigPbk);
+            const responderPbk = yield KFS.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 KFS.asKey(plainInitiatorOneTimePbkCipher.sharedKey);
+            const rkWrappedSharedKey = yield this.encryptionService.encrypt(rootKey.jwk, sharedKey.toJSON(true));
+            const mkSharedKey = yield KFS.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)),
+                };
+            }
+            // Get the data needed from the initiator's cipher data.
+            let initiatorContactCardCipherInput;
+            let initiatorContactCardSharedCipherInput;
+            if (plainInitiatorRootKeyCipher.initiatorContactCard) {
+                const initiatorContactCard = plainInitiatorRootKeyCipher.initiatorContactCard;
+                const ownerKey = yield this.keyFactory.createKey();
+                const sharedCipherKey = yield KFS.asKey(plainInitiatorOneTimePbkCipher.responder.contactCard.sharedCipherKey);
+                const ownerWrappedKey = JSON.stringify(yield this.encryptionService.encrypt(rootKey.jwk, ownerKey.toJSON(true)));
+                const ownerCipherData = initiatorContactCard.plainOwnerCipherDataJson
+                    ? JSON.stringify(yield this.encryptionService.encrypt(ownerKey, initiatorContactCard.plainOwnerCipherDataJson))
+                    : '';
+                initiatorContactCardCipherInput = {
+                    ownerWrappedKey,
+                    ownerWrappingKeyId: rootKey.id,
+                    ownerCipherData,
+                };
+                initiatorContactCardSharedCipherInput = {
+                    sigPxkId: initiatorSigPrk.id,
+                };
+                const sharedCipherData = yield this.encryptionService.encrypt(sharedCipherKey, initiatorContactCard.plainSharedCipherDataJson);
+                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.
+            const res = yield this.lrApollo.mutate({
+                mutation: CompleteOtkMutation,
+                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,
+                    },
+                },
+            });
+            return res.completeKeyExchangeOtk;
+        });
+    }
+    currentUserSharedKey(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { currentUserSharedKey } = yield this.lrApollo.query({
+                query: CurrentUserSharedKeyQuery,
+                variables: {
+                    username: input.username,
+                    userId: input.userId,
+                },
+            });
+            return currentUserSharedKey.userSharedKey;
+        });
+    }
+}
+KeyExchangeService.ɵprov = i0.ɵɵdefineInjectable({ factory: function KeyExchangeService_Factory() { return new KeyExchangeService(i0.ɵɵinject(i1.KeyFactoryService), i0.ɵɵinject(i2.KeyService), i0.ɵɵinject(i3.LrApolloService), i0.ɵɵinject(i4.EncryptionService), i0.ɵɵinject(i5.LifeReadyAuthService), i0.ɵɵinject(i6.UserService)); }, token: KeyExchangeService, providedIn: "root" });
+KeyExchangeService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+KeyExchangeService.ctorParameters = () => [
+    { type: KFS },
+    { type: KeyService },
+    { type: LrApolloService },
+    { type: EncryptionService },
+    { type: LifeReadyAuthService },
+    { type: UserService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-exchange.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/api/key-exchange.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { JWK } from 'node-jose';\r\nimport { LifeReadyAuthService } from '../auth/life-ready-auth.service';\r\nimport { KeyGraphResponse } from '../cryptography/cryptography.types';\r\nimport {\r\n  EncryptionService,\r\n  JoseSerialization,\r\n} from '../cryptography/encryption.service';\r\nimport { KeyService } from '../cryptography/key.service';\r\nimport { LrCodeMismatchException } from '../_common/exceptions';\r\nimport { UserService } from './../users/user.service';\r\nimport {\r\n  CompleteOtkMutation,\r\n  CurrentUserSharedKeyQuery,\r\n  InitiateOtkMutation,\r\n  KeyExchangeQuery,\r\n  KeyExchangesQuery,\r\n  KeyExchangeTokenQuery,\r\n  RespondOtkMutation,\r\n} from './key-exchange.gql';\r\nimport {\r\n  CompleteOtk,\r\n  DecryptedKeyExchange,\r\n  DecryptedOtk,\r\n  GetKeyExchangeListOptions,\r\n  GetKeyExchangeOptions,\r\n  InitiateOtkInput,\r\n  KeyExchange,\r\n  OtkState,\r\n  PlainInitiatorOneTimePbkCipher,\r\n  PlainInitiatorRootKeyCipher,\r\n  PlainOtKeyCipher,\r\n  PlainResponderPbkCipher,\r\n  RespondOtk,\r\n  RespondOtkInput,\r\n  UserSharedKey,\r\n} from './key-exchange.types';\r\nimport { LrApolloService } from './lr-apollo.service';\r\nimport { KeyFactoryService as KFS } from '../cryptography/key-factory.service';\r\n// Ref: https://stackoverflow.com/questions/59735280/angular-8-moment-error-cannot-call-a-namespace-moment\r\nimport * as moment_ from 'moment';\r\nconst moment = moment_;\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class KeyExchangeService {\r\n  private readonly CLIENT_NONCE_LENGTH = 32;\r\n\r\n  constructor(\r\n    private keyFactory: KFS,\r\n    private keyService: KeyService,\r\n    private lrApollo: LrApolloService,\r\n    private encryptionService: EncryptionService,\r\n    private authService: LifeReadyAuthService,\r\n    private userService: UserService\r\n  ) {}\r\n\r\n  public async getKeyExchangeList(\r\n    input: GetKeyExchangeListOptions = {}\r\n  ): Promise<any> {\r\n    const { keyExchanges } = await this.lrApollo.query<{\r\n      keyExchanges: any;\r\n      keyGraph: KeyGraphResponse;\r\n    }>({\r\n      query: KeyExchangesQuery,\r\n      variables: {\r\n        ...input,\r\n      },\r\n    });\r\n    return keyExchanges;\r\n  }\r\n\r\n  /**\r\n   * @param id If the current user can responder the key exchange if they are either the initiator or the receiver.\r\n   * @param token If not signed in, or not the initiator or responder, 'token' must be given.\r\n   * @param otKeyK Is the raw one-time key (string). If the responder is explicitly specified at time of initiation, then\r\n   *   it's possible to have the otKey wrapped by the public key of the responder. In which case, the otKeyK is not needed.\r\n   */\r\n  public async getKeyExchange(\r\n    id: string,\r\n    { otKeyK, token }: GetKeyExchangeOptions = {}\r\n  ): Promise<DecryptedKeyExchange> {\r\n    const { keyExchange } = await this.lrApollo.query<{\r\n      keyExchange: KeyExchange;\r\n      keyGraph: KeyGraphResponse;\r\n    }>({\r\n      query: token ? KeyExchangeTokenQuery : KeyExchangeQuery,\r\n      variables: {\r\n        id,\r\n        token,\r\n      },\r\n    });\r\n    return await this.decryptKeyExchange(keyExchange, otKeyK);\r\n  }\r\n\r\n  private async decryptResponseCipher(\r\n    otKey: JWK.Key,\r\n    otPrk: JWK.Key,\r\n    content: any\r\n  ): Promise<PlainInitiatorOneTimePbkCipher> {\r\n    // The response could be wrapped by the OtK as well as we the OtPrk\r\n    try {\r\n      content = await this.encryptionService.decrypt(otKey, content);\r\n    } catch (error) {\r\n      if (error.message !== 'no key found') {\r\n        throw error;\r\n      }\r\n      // Do nothing to support older versions where message is not wrapped with otk.\r\n    }\r\n\r\n    // The Prk is single-use and only used to send information from the responder back to the initiator.\r\n    return await this.encryptionService.decrypt(otPrk, content);\r\n  }\r\n\r\n  public async decryptKeyExchange(\r\n    keyExchange: KeyExchange,\r\n    otKeyK?: string\r\n  ): Promise<DecryptedKeyExchange> {\r\n    if (keyExchange.isInitiator) {\r\n      const rootKey = await this.keyService.getCurrentRootKey();\r\n      // Decrypt using the root key to get the Prk\r\n      const plainInitiatorRootKeyCipher = ((await this.encryptionService.decrypt(\r\n        rootKey.jwk,\r\n        keyExchange.initiatorRootKeyCipher\r\n      )) as unknown) as PlainInitiatorRootKeyCipher;\r\n\r\n      const plainInitiatorOneTimePbkCipher = keyExchange.otk\r\n        .initiatorOneTimePbkCipher\r\n        ? await this.decryptResponseCipher(\r\n            await KFS.asKey(plainInitiatorRootKeyCipher.otKey),\r\n            await KFS.asKey(plainInitiatorRootKeyCipher.oneTimePrk),\r\n            keyExchange.otk.initiatorOneTimePbkCipher\r\n          )\r\n        : null;\r\n\r\n      const responder =\r\n        plainInitiatorOneTimePbkCipher &&\r\n        plainInitiatorOneTimePbkCipher.responder;\r\n      const initiator =\r\n        plainInitiatorRootKeyCipher && plainInitiatorRootKeyCipher.initiator;\r\n\r\n      return {\r\n        ...keyExchange,\r\n        message: responder ? responder.message : null,\r\n        contactCard:\r\n          responder && responder.contactCard\r\n            ? responder.contactCard.plainSharedCipherDataJson\r\n            : null,\r\n        myContactCard:\r\n          initiator && initiator.contactCard\r\n            ? initiator.contactCard.plainSharedCipherDataJson\r\n            : null,\r\n        myMessage: initiator && initiator.message,\r\n      };\r\n    } else {\r\n      const decryptedOtk = await this.decryptOtk(keyExchange, otKeyK);\r\n\r\n      const initiator = decryptedOtk && decryptedOtk.plainOtKeyCipher.initiator;\r\n\r\n      return {\r\n        ...keyExchange,\r\n        decryptedOtk,\r\n        message: initiator && initiator.message,\r\n        contactCard:\r\n          initiator &&\r\n          initiator.contactCard &&\r\n          initiator.contactCard.plainSharedCipherDataJson,\r\n      };\r\n    }\r\n  }\r\n\r\n  private async decryptOtk(\r\n    keyExchange: KeyExchange,\r\n    otKeyK?: string\r\n  ): Promise<DecryptedOtk> {\r\n    const otKey = await this.getOtKey(keyExchange, otKeyK);\r\n\r\n    return otKey && keyExchange.otk.otKeyCipher\r\n      ? {\r\n          plainOtKeyCipher: await this.encryptionService.decrypt(\r\n            otKey,\r\n            keyExchange.otk.otKeyCipher\r\n          ),\r\n          otKey,\r\n        }\r\n      : null;\r\n  }\r\n\r\n  private async getOtKey(\r\n    keyExchange: KeyExchange,\r\n    otKeyK?: string\r\n  ): Promise<JWK.Key> {\r\n    if (otKeyK) {\r\n      return await KFS.asKey({\r\n        ...JSON.parse(keyExchange.otk.otKeyParams),\r\n        k: otKeyK,\r\n      });\r\n    } else if (\r\n      keyExchange.otk.state === OtkState.OTK_INITIATED &&\r\n      !keyExchange.isInitiator &&\r\n      keyExchange.otk.responderPbkCipher\r\n    ) {\r\n      // Assuming existing user getting invited where OTK is wrapped in responder's public key.\r\n      const prk = await this.keyService.getCurrentPxk();\r\n      const decryptedCipher: any = await this.encryptionService.decrypt(\r\n        prk.jwk,\r\n        JSON.parse(keyExchange.otk.responderPbkCipher),\r\n        {\r\n          serializations: [JoseSerialization.COMPACT],\r\n        }\r\n      );\r\n      if (decryptedCipher.otKey) {\r\n        return await KFS.asKey(decryptedCipher.otKey);\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  async initiateOtk({\r\n    message,\r\n    email,\r\n    contactCard,\r\n    upgrade,\r\n  }: InitiateOtkInput): Promise<{ keyExchange: KeyExchange; otKeyK: string }> {\r\n    const otKey = await this.keyFactory.createKey();\r\n    const nonce = this.keyFactory.randomString(this.CLIENT_NONCE_LENGTH);\r\n    const user = await this.authService.getUser();\r\n\r\n    // New PKC key for encryption. This key is used only once when the responder sends\r\n    // back their signing public key.\r\n    const initiatorOneTimePrk = await this.keyFactory.createPkcKey();\r\n\r\n    // Option 1: New PKC key for signing\r\n    // const initiatorSigPrk = await this.keyService.createPkcSignKey();\r\n\r\n    // Option 2: Use the user's global signing key.\r\n    // This key is used to prove the initiator's identity.\r\n    const initiatorPrk = await this.keyService.getCurrentPxk();\r\n    const initiatorSigPrk = await this.keyService.getCurrentSigPxk();\r\n\r\n    let initiatorPlainDataSig: string = null;\r\n\r\n    if (contactCard && contactCard.ownerPlainData) {\r\n      initiatorPlainDataSig = JSON.stringify(\r\n        await this.encryptionService.sign(\r\n          initiatorSigPrk.jwk,\r\n          contactCard.ownerPlainData\r\n        )\r\n      );\r\n    }\r\n\r\n    const initiator = {\r\n      message,\r\n      contactCard: contactCard\r\n        ? {\r\n            plainSharedCipherDataJson: contactCard.plainSharedCipherDataJson,\r\n          }\r\n        : null,\r\n    };\r\n\r\n    // Content to be encrypted using the OTK.\r\n    const plainOtKeyCipher: PlainOtKeyCipher = {\r\n      nonce,\r\n      initiator: {\r\n        ...initiator,\r\n        oneTimePbk: initiatorOneTimePrk.toJSON(), // onetime public encryption key responder use to send data back to initiator\r\n        pbk: initiatorPrk.jwk.toJSON(), // public encryption key\r\n        sigPbk: initiatorSigPrk.jwk.toJSON(), // public signing key\r\n        profile: {\r\n          username: user.username,\r\n        },\r\n      },\r\n    };\r\n\r\n    const otKeyCipher = await this.encryptionService.encrypt(\r\n      otKey,\r\n      plainOtKeyCipher\r\n    );\r\n\r\n    // Content to be encrypted using the initiator's root key.\r\n    const plainInitiatorRootKeyCipher: PlainInitiatorRootKeyCipher = {\r\n      nonce,\r\n      oneTimePrk: initiatorOneTimePrk.toJSON(true),\r\n      // Should not need to keep this encrypted since we are using the global signing key.\r\n      // sigPrk: initiatorSigPrk.toJSON(true),\r\n\r\n      // Save it in case the initiator want to decode the otKeyCipher.\r\n      // Since the otKey is only used once, and that otKeyCipher contains only\r\n      // the public key of the initiator, it's safe just leave the otKey stored here.\r\n      otKey: otKey.toJSON(true),\r\n      // These should be storing information such as how the fields of the shared contact card is\r\n      // derived from the master contact card.\r\n      initiatorContactCard: contactCard,\r\n      initiator,\r\n    };\r\n\r\n    const rootKey = await this.keyService.getCurrentRootKey();\r\n    const initiatorRootKeyCipher = await this.encryptionService.encrypt(\r\n      rootKey.jwk,\r\n      plainInitiatorRootKeyCipher\r\n    );\r\n\r\n    // The raw OTK\r\n    const otKeyK: string = (otKey.toJSON(true) as any).k;\r\n\r\n    // API call\r\n    const { initiateKeyExchangeOtk } = await this.lrApollo.mutate<any>({\r\n      mutation: InitiateOtkMutation,\r\n      variables: {\r\n        input: {\r\n          // These will be stored on the server\r\n          initiatorRootKeyCipher: JSON.stringify(initiatorRootKeyCipher),\r\n          initiatorPxkId: initiatorPrk.id,\r\n          initiatorSigPxkId: initiatorSigPrk.id,\r\n          // These will be sent to the responder\r\n          otKeyParams: JSON.stringify(otKey.toJSON()),\r\n          otKeyCipher: JSON.stringify(otKeyCipher),\r\n          sendEmail: email\r\n            ? {\r\n                email,\r\n                rawOtKey: otKeyK,\r\n              }\r\n            : null,\r\n          createTp: true,\r\n          initiatorPlainDataSig,\r\n          upgrade,\r\n        },\r\n      },\r\n    });\r\n    return { keyExchange: initiateKeyExchangeOtk.keyExchange, otKeyK };\r\n  }\r\n\r\n  async respondOtk({\r\n    id,\r\n    token,\r\n    decryptedOtk,\r\n    message,\r\n    initiatorContactCard,\r\n    responderContactCard: sentContactCard,\r\n  }: RespondOtkInput): Promise<RespondOtk> {\r\n    const user = await this.authService.getUser();\r\n    const rootKey = await this.keyService.getCurrentRootKey();\r\n\r\n    const masterKeyId = this.keyService.getCurrentMasterKey().id;\r\n    const masterKey = await this.keyService.getCurrentMasterKey();\r\n\r\n    const sharedKey = await this.keyFactory.createKey();\r\n    const mkSharedKey = await this.keyFactory.createKey();\r\n\r\n    const rkWrappedSharedKey = await this.encryptionService.encrypt(\r\n      rootKey.jwk,\r\n      sharedKey.toJSON(true)\r\n    );\r\n    const mkWrappedMkSharedKey = await this.encryptionService.encrypt(\r\n      masterKey.jwk,\r\n      mkSharedKey.toJSON(true)\r\n    );\r\n\r\n    const initiatorOneTimePbk = await KFS.asKey(\r\n      decryptedOtk.plainOtKeyCipher.initiator.oneTimePbk\r\n    );\r\n\r\n    const initiatorPbk = await KFS.asKey(\r\n      decryptedOtk.plainOtKeyCipher.initiator.pbk\r\n    );\r\n    const initiatorSigPbk = await KFS.asKey(\r\n      decryptedOtk.plainOtKeyCipher.initiator.sigPbk\r\n    );\r\n\r\n    // Option 1: Using new Prk for each TP pair\r\n    // Create a new public signing key for the responder.\r\n    // const responderSigPrk = await this.keyService.createPkcSignKey()\r\n    // const rkWrappedResponderSigPrk = await this.encrypt(rootKey, responderSigPrk.toJSON(true));\r\n\r\n    // Option 2: Responder already has a signing Prk\r\n    const responderPrk = await this.keyService.getCurrentPxk();\r\n    const responderSigPrk = await this.keyService.getCurrentSigPxk();\r\n\r\n    const signedInitiatorPbk = await this.encryptionService.sign(\r\n      responderSigPrk.jwk,\r\n      initiatorPbk.toJSON()\r\n    );\r\n    const signedInitiatorSigPbk = await this.encryptionService.sign(\r\n      responderSigPrk.jwk,\r\n      initiatorSigPbk.toJSON()\r\n    );\r\n\r\n    const plainInitiatorOneTimePbkCipher: PlainInitiatorOneTimePbkCipher = {\r\n      nonce: decryptedOtk.plainOtKeyCipher.nonce,\r\n      sharedKey: sharedKey.toJSON(true),\r\n      mkSharedKey: mkSharedKey.toJSON(true),\r\n      responder: {\r\n        pbk: responderPrk.jwk.toJSON(), // public key\r\n        sigPbk: responderSigPrk.jwk.toJSON(), // public key\r\n        profile: {\r\n          username: user.username,\r\n        },\r\n        message,\r\n      },\r\n    };\r\n\r\n    let receivedCardInput;\r\n    if (decryptedOtk.plainOtKeyCipher.initiator.contactCard) {\r\n      // Set the info about the initiator to be the ones sent by the initiator. We need th responder to do the encryption here\r\n      // because the initiator does not have the shared key yet, and we want the responder to have a functional contact card after\r\n      // this exchange. The initiator can double check the contact details are correct and sign it when it completes the exchange.\r\n      const plainSharedCipherDataJson =\r\n        decryptedOtk.plainOtKeyCipher.initiator.contactCard\r\n          .plainSharedCipherDataJson;\r\n\r\n      // Create keys\r\n      const receiverKey = await this.keyFactory.createKey();\r\n      const ccSharedKey = await this.keyFactory.createKey();\r\n      const sigPxk = await this.keyService.getCurrentSigPxk();\r\n\r\n      receivedCardInput = {\r\n        receiverWrappedKey: JSON.stringify(\r\n          await this.encryptionService.encrypt(\r\n            rootKey.jwk,\r\n            receiverKey.toJSON(true)\r\n          )\r\n        ),\r\n        receiverWrappingKeyId: rootKey.id,\r\n        receiverCipherData: initiatorContactCard\r\n          ? JSON.stringify(\r\n              await this.encryptionService.encrypt(\r\n                receiverKey,\r\n                initiatorContactCard.plainReceiverCipherDataJson\r\n              )\r\n            )\r\n          : '',\r\n        sharedWrappedKey: JSON.stringify(\r\n          await this.encryptionService.encrypt(\r\n            sharedKey,\r\n            ccSharedKey.toJSON(true)\r\n          )\r\n        ),\r\n      };\r\n\r\n      const sharedCipherData = await this.encryptionService.encrypt(\r\n        ccSharedKey,\r\n        plainSharedCipherDataJson\r\n      );\r\n      receivedCardInput.sharedCipherDataSig = JSON.stringify(\r\n        await this.encryptionService.sign(sigPxk.jwk, sharedCipherData)\r\n      );\r\n      receivedCardInput.sigPxkId = sigPxk.id;\r\n\r\n      plainInitiatorOneTimePbkCipher.responder.contactCard = {\r\n        ...plainInitiatorOneTimePbkCipher.responder.contactCard,\r\n        sharedCipherKey: ccSharedKey.toJSON(true),\r\n      };\r\n    }\r\n\r\n    let sentCardInput;\r\n    if (sentContactCard) {\r\n      // Create keys\r\n      const ownerKey = await this.keyFactory.createKey();\r\n      const ccSharedKey = await this.keyFactory.createKey();\r\n      const sigPxk = await this.keyService.getCurrentSigPxk();\r\n\r\n      sentCardInput = {\r\n        ownerWrappedKey: JSON.stringify(\r\n          await this.encryptionService.encrypt(\r\n            rootKey.jwk,\r\n            ownerKey.toJSON(true)\r\n          )\r\n        ),\r\n        ownerWrappingKeyId: rootKey.id,\r\n        ownerCipherData: sentContactCard.plainOwnerCipherDataJson\r\n          ? JSON.stringify(\r\n              await this.encryptionService.encrypt(\r\n                ownerKey,\r\n                sentContactCard.plainOwnerCipherDataJson\r\n              )\r\n            )\r\n          : '',\r\n\r\n        sharedWrappedKey: JSON.stringify(\r\n          await this.encryptionService.encrypt(\r\n            sharedKey,\r\n            ccSharedKey.toJSON(true)\r\n          )\r\n        ),\r\n      };\r\n\r\n      const sharedCipherData = await this.encryptionService.encrypt(\r\n        ccSharedKey,\r\n        sentContactCard.plainSharedCipherDataJson\r\n      );\r\n      sentCardInput.sharedCipherDataSig = JSON.stringify(\r\n        await this.encryptionService.sign(sigPxk.jwk, sharedCipherData)\r\n      );\r\n      sentCardInput.sigPxkId = sigPxk.id;\r\n\r\n      if (sentContactCard.ownerPlainData) {\r\n        sentCardInput.ownerPlainDataSig = JSON.stringify(\r\n          await this.encryptionService.sign(\r\n            responderSigPrk.jwk,\r\n            sentContactCard.ownerPlainData\r\n          )\r\n        );\r\n      }\r\n\r\n      // Contact card info readable by the initiator\r\n      plainInitiatorOneTimePbkCipher.responder.contactCard = {\r\n        ...plainInitiatorOneTimePbkCipher.responder.contactCard,\r\n        plainSharedCipherDataJson: sentContactCard.plainSharedCipherDataJson,\r\n      };\r\n    }\r\n\r\n    // Encrypt with one-time public key\r\n    let initiatorOneTimePbkCipher = await this.encryptionService.encrypt(\r\n      initiatorOneTimePbk,\r\n      plainInitiatorOneTimePbkCipher\r\n    );\r\n\r\n    // Encrypt with the otk again to keep use of asymmetric keys to a minimum.\r\n    initiatorOneTimePbkCipher = await this.encryptionService.encrypt(\r\n      decryptedOtk.otKey,\r\n      initiatorOneTimePbkCipher\r\n    );\r\n\r\n    const { respondKeyExchangeOtk } = await this.lrApollo.mutate<any>({\r\n      mutation: RespondOtkMutation,\r\n      variables: {\r\n        input: {\r\n          keyExchangeId: id,\r\n          keyExchangeToken: token,\r\n          rootKeyId: rootKey.id,\r\n          masterKeyId,\r\n          // These will be stored on the server\r\n          responderPxkId: responderPrk.id,\r\n          responderSigPxkId: responderSigPrk.id,\r\n          signedInitiatorPbk: JSON.stringify(signedInitiatorPbk),\r\n          signedInitiatorSigPbk: JSON.stringify(signedInitiatorSigPbk),\r\n          // rkWrappedInitiatorSigPbk: JSON.stringify(rkWrappedInitiatorSigPbk),\r\n\r\n          // Option 1: Using new Prk for each TP pair\r\n          // rkWrappedResponderSigPrk: JSON.stringify(rkWrappedResponderSigPrk),\r\n          rkWrappedSharedKey: JSON.stringify(rkWrappedSharedKey),\r\n          mkWrappedMkSharedKey: JSON.stringify(mkWrappedMkSharedKey),\r\n          // These will be sent to the initiator\r\n          initiatorOneTimePbkCipher: JSON.stringify(initiatorOneTimePbkCipher),\r\n          initiatorContactCard: receivedCardInput,\r\n          responderContactCard: sentCardInput,\r\n        },\r\n      },\r\n    });\r\n\r\n    return {\r\n      keyExchange: respondKeyExchangeOtk.keyExchange,\r\n      userSharedKey: respondKeyExchangeOtk.userSharedKey,\r\n      tp: respondKeyExchangeOtk.tp,\r\n    };\r\n  }\r\n\r\n  async completeOtk(\r\n    keyExchangeId: string,\r\n    initiatorRootKeyCipher: string,\r\n    initiatorOneTimePbkCipher: string,\r\n    responderContactCard?: string\r\n  ): Promise<CompleteOtk> {\r\n    const rootKey = await this.keyService.getCurrentRootKey();\r\n    const masterKey = await this.keyService.getCurrentMasterKey();\r\n\r\n    // Decrypt using the root key to get the Prk\r\n    const plainInitiatorRootKeyCipher = ((await this.encryptionService.decrypt(\r\n      rootKey.jwk,\r\n      initiatorRootKeyCipher\r\n    )) as unknown) as PlainInitiatorRootKeyCipher;\r\n\r\n    // The Prk is single-use and only used to send information from the responder back to the initiator.\r\n    const plainInitiatorOneTimePbkCipher = await this.decryptResponseCipher(\r\n      await KFS.asKey(plainInitiatorRootKeyCipher.otKey),\r\n      await KFS.asKey(plainInitiatorRootKeyCipher.oneTimePrk),\r\n      initiatorOneTimePbkCipher\r\n    );\r\n\r\n    // Check the nonce match to ensure the responder was the one holding the OTK\r\n    if (\r\n      plainInitiatorRootKeyCipher.nonce !== plainInitiatorOneTimePbkCipher.nonce\r\n    ) {\r\n      throw new LrCodeMismatchException(\r\n        'The nonce returned by responder does not match with the one created by the initiator.'\r\n      );\r\n    }\r\n\r\n    // Option 1: Assuming the signing key is unique between users.\r\n    // const initiatorSigPrk = await KFS.asKey(ke.plainInitiatorRootKeyCipher.sigPrk);\r\n    // const rkWrappedInitiatorSigPrk = await this.encrypt(rootKey, initiatorSigPrk.toJSON(true));\r\n\r\n    // Option 2: Use the user's global signing key.\r\n    // In this case the initiatorSigPrk is already a part of the key graph.\r\n    // So there's nothing to do here.\r\n\r\n    // Protected the signing public key of the responder.\r\n    const initiatorSigPrk = await this.keyService.getCurrentSigPxk();\r\n    const responderSigPbk = await KFS.asKey(\r\n      plainInitiatorOneTimePbkCipher.responder.sigPbk\r\n    );\r\n    const responderPbk = await KFS.asKey(\r\n      plainInitiatorOneTimePbkCipher.responder.pbk\r\n    );\r\n\r\n    const signedResponderPbk = await this.encryptionService.sign(\r\n      initiatorSigPrk.jwk,\r\n      responderPbk.toJSON()\r\n    );\r\n    const signedResponderSigPbk = await this.encryptionService.sign(\r\n      initiatorSigPrk.jwk,\r\n      responderSigPbk.toJSON()\r\n    );\r\n\r\n    const sharedKey = await KFS.asKey(plainInitiatorOneTimePbkCipher.sharedKey);\r\n    const rkWrappedSharedKey = await this.encryptionService.encrypt(\r\n      rootKey.jwk,\r\n      sharedKey.toJSON(true)\r\n    );\r\n\r\n    const mkSharedKey = await KFS.asKey(\r\n      plainInitiatorOneTimePbkCipher.mkSharedKey\r\n    );\r\n    const mkWrappedMkSharedKey = await this.encryptionService.encrypt(\r\n      masterKey.jwk,\r\n      mkSharedKey.toJSON(true)\r\n    );\r\n\r\n    let responderContactCardCipherInput;\r\n    if (responderContactCard) {\r\n      // Create key\r\n      const receiverKey = await this.keyFactory.createKey();\r\n\r\n      responderContactCardCipherInput = {\r\n        receiverWrappedKey: JSON.stringify(\r\n          await this.encryptionService.encrypt(\r\n            rootKey.jwk,\r\n            receiverKey.toJSON(true)\r\n          )\r\n        ),\r\n        receiverWrappingKeyId: rootKey.id,\r\n        receiverCipherData: JSON.stringify(\r\n          await this.encryptionService.encrypt(\r\n            receiverKey,\r\n            responderContactCard\r\n          )\r\n        ),\r\n      };\r\n    }\r\n\r\n    // Get the data needed from the initiator's cipher data.\r\n    let initiatorContactCardCipherInput;\r\n    let initiatorContactCardSharedCipherInput;\r\n    if (plainInitiatorRootKeyCipher.initiatorContactCard) {\r\n      const initiatorContactCard =\r\n        plainInitiatorRootKeyCipher.initiatorContactCard;\r\n      const ownerKey = await this.keyFactory.createKey();\r\n      const sharedCipherKey = await KFS.asKey(\r\n        plainInitiatorOneTimePbkCipher.responder.contactCard.sharedCipherKey\r\n      );\r\n\r\n      const ownerWrappedKey = JSON.stringify(\r\n        await this.encryptionService.encrypt(rootKey.jwk, ownerKey.toJSON(true))\r\n      );\r\n      const ownerCipherData = initiatorContactCard.plainOwnerCipherDataJson\r\n        ? JSON.stringify(\r\n            await this.encryptionService.encrypt(\r\n              ownerKey,\r\n              initiatorContactCard.plainOwnerCipherDataJson\r\n            )\r\n          )\r\n        : '';\r\n\r\n      initiatorContactCardCipherInput = {\r\n        ownerWrappedKey,\r\n        ownerWrappingKeyId: rootKey.id,\r\n        ownerCipherData,\r\n      };\r\n\r\n      initiatorContactCardSharedCipherInput = {\r\n        sigPxkId: initiatorSigPrk.id,\r\n      };\r\n\r\n      const sharedCipherData = await this.encryptionService.encrypt(\r\n        sharedCipherKey,\r\n        initiatorContactCard.plainSharedCipherDataJson\r\n      );\r\n      initiatorContactCardSharedCipherInput.sharedCipherDataSig = JSON.stringify(\r\n        await this.encryptionService.sign(initiatorSigPrk.jwk, sharedCipherData)\r\n      );\r\n    }\r\n\r\n    // TODO ideally we update the shared data in the contact card sent to the responder as well since that\r\n    // CC was created by the responder.\r\n\r\n    const res = await this.lrApollo.mutate<any>({\r\n      mutation: CompleteOtkMutation,\r\n      variables: {\r\n        input: {\r\n          keyExchangeId,\r\n          rootKeyId: rootKey.id,\r\n          masterKeyId: masterKey.id,\r\n          initiatorSigPxkId: initiatorSigPrk.id,\r\n          signedResponderPbk: JSON.stringify(signedResponderPbk),\r\n          signedResponderSigPbk: JSON.stringify(signedResponderSigPbk),\r\n          rkWrappedSharedKey: JSON.stringify(rkWrappedSharedKey),\r\n          mkWrappedMkSharedKey: JSON.stringify(mkWrappedMkSharedKey),\r\n          responderContactCardCipher: responderContactCardCipherInput,\r\n          initiatorContactCardCipher: initiatorContactCardCipherInput,\r\n          initiatorContactCardSharedCipher: initiatorContactCardSharedCipherInput,\r\n        },\r\n      },\r\n    });\r\n    return res.completeKeyExchangeOtk;\r\n  }\r\n\r\n  public async currentUserSharedKey(input: {\r\n    username?: string;\r\n    userId?: string;\r\n  }): Promise<UserSharedKey> {\r\n    const { currentUserSharedKey } = await this.lrApollo.query<any>({\r\n      query: CurrentUserSharedKeyQuery,\r\n      variables: {\r\n        username: input.username,\r\n        userId: input.userId,\r\n      },\r\n    });\r\n    return currentUserSharedKey.userSharedKey;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/api/key-exchange.types.js

@@ -0,0 +1,18 @@
+export var OtkState;
+(function (OtkState) {
+    OtkState["OTK_INITIATED"] = "OTK_INITIATED";
+    OtkState["OTK_ACCEPTED"] = "OTK_ACCEPTED";
+    OtkState["OTK_COMPLETED"] = "OTK_COMPLETED";
+})(OtkState || (OtkState = {}));
+export var KeyExchangeState;
+(function (KeyExchangeState) {
+    KeyExchangeState["IN_PROGRESS"] = "IN_PROGRESS";
+    KeyExchangeState["COMPLETED"] = "COMPLETED";
+    KeyExchangeState["DECLINED"] = "DECLINED";
+    KeyExchangeState["CANCELLED"] = "CANCELLED";
+})(KeyExchangeState || (KeyExchangeState = {}));
+export var KeyExchangeMode;
+(function (KeyExchangeMode) {
+    KeyExchangeMode["OTK"] = "OTK";
+})(KeyExchangeMode || (KeyExchangeMode = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-exchange.types.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/api/key-exchange.types.ts"],"names":[],"mappings":"AAsFA,MAAM,CAAN,IAAY,QAIX;AAJD,WAAY,QAAQ;IAClB,2CAA+B,CAAA;IAC/B,yCAA6B,CAAA;IAC7B,2CAA+B,CAAA;AACjC,CAAC,EAJW,QAAQ,KAAR,QAAQ,QAInB;AAgCD,MAAM,CAAN,IAAY,gBAKX;AALD,WAAY,gBAAgB;IAC1B,+CAA2B,CAAA;IAC3B,2CAAuB,CAAA;IACvB,yCAAqB,CAAA;IACrB,2CAAuB,CAAA;AACzB,CAAC,EALW,gBAAgB,KAAhB,gBAAgB,QAK3B;AAED,MAAM,CAAN,IAAY,eAEX;AAFD,WAAY,eAAe;IACzB,8BAAW,CAAA;AACb,CAAC,EAFW,eAAe,KAAf,eAAe,QAE1B","sourcesContent":["import { Key } from '../cryptography/cryptography.types';\r\nimport { AccessLevel } from '../category/category.types';\r\nimport { JWK } from 'node-jose';\r\nimport { ContactCardName, TrustedPartyDetails } from '../users/profile.types';\r\n\r\n// Will be encrypted using the root key of the initiator\r\nexport interface PlainInitiatorRootKeyCipher {\r\n  nonce: string;\r\n  oneTimePrk: object; // onetime public encryption key responder use to send data back to initiator\r\n  otKey: object;\r\n  initiatorContactCard?: {\r\n    // Owner only access to this data\r\n    plainOwnerCipherDataJson: any;\r\n    // Shared read access between owner and receiver. Only the owner has write access.\r\n    plainSharedCipherDataJson: any;\r\n  };\r\n  initiator: {\r\n    message?: KeyExchangeMessage;\r\n    contactCard?: {\r\n      // Shared read access between owner and receiver. Only the owner has write access.\r\n      plainSharedCipherDataJson: TrustedPartyDetails;\r\n    };\r\n  };\r\n}\r\n\r\nexport interface SharedContactCardInput {\r\n  plainCipherDataJson?: any;\r\n  plainSharedCipherDataJson?: any;\r\n  sharedCipherKey?: object;\r\n}\r\n\r\nexport interface PreparedPermissions {\r\n  categories?: { categoryId: string; accessLevel: AccessLevel }[];\r\n  records?: { recordId: string; accessLevel: AccessLevel }[];\r\n}\r\n\r\nexport interface KeyExchangeMessage {\r\n  name?: string;\r\n  email?: string;\r\n  message?: string;\r\n  permissions?: PreparedPermissions;\r\n}\r\n\r\nexport interface PlainOtKeyCipher {\r\n  nonce: string;\r\n  initiator: {\r\n    oneTimePbk: object; // onetime public encryption key responder use to send data back to initiator\r\n    pbk: object; // public encryption key\r\n    sigPbk: object; // public signing key\r\n    profile?: {\r\n      username?: string;\r\n    };\r\n    message?: KeyExchangeMessage;\r\n    contactCard?: {\r\n      // Shared read access between owner and receiver. Only the owner has write access.\r\n      plainSharedCipherDataJson: TrustedPartyDetails;\r\n    };\r\n  };\r\n}\r\n\r\nexport interface DecryptedOtk {\r\n  plainOtKeyCipher: PlainOtKeyCipher;\r\n  otKey: JWK.Key; // The one-time key\r\n}\r\n\r\nexport interface PlainInitiatorOneTimePbkCipher {\r\n  nonce: string;\r\n  sharedKey: object;\r\n  mkSharedKey: object;\r\n  responder: {\r\n    pbk: object;\r\n    sigPbk: object;\r\n    profile?: {\r\n      username?: string;\r\n    };\r\n    message?: KeyExchangeMessage;\r\n    contactCard?: {\r\n      plainSharedCipherDataJson: TrustedPartyDetails;\r\n      // Note that this is _not_ the same key as the sharedKey. The sharedKey wraps\r\n      // this key in the key graph. But because this key has not been entered into\r\n      // the key graph then the responder calls the API, we pass the JWK directly here.\r\n      sharedCipherKey: object;\r\n    };\r\n  };\r\n}\r\n\r\nexport enum OtkState {\r\n  OTK_INITIATED = 'OTK_INITIATED',\r\n  OTK_ACCEPTED = 'OTK_ACCEPTED',\r\n  OTK_COMPLETED = 'OTK_COMPLETED',\r\n}\r\n\r\nexport interface KeyExchangeContactCardInput {\r\n  // Accessible by the server and initiator. Server side notification emails need to know some\r\n  // information about the initiator.\r\n  ownerPlainData?: {\r\n    name: ContactCardName;\r\n  };\r\n  // Owner only access to this data\r\n  plainOwnerCipherDataJson: any;\r\n  // Shared read access between owner and receiver. Only the owner has write access.\r\n  plainSharedCipherDataJson: TrustedPartyDetails;\r\n}\r\n\r\nexport interface InitiateOtkInput {\r\n  email?: string;\r\n  message?: KeyExchangeMessage;\r\n  contactCard?: KeyExchangeContactCardInput;\r\n  upgrade?: boolean;\r\n}\r\n\r\nexport interface RespondOtkInput {\r\n  id: string;\r\n  token: string;\r\n  decryptedOtk: DecryptedOtk;\r\n  message?: KeyExchangeMessage;\r\n  initiatorContactCard?: {\r\n    plainReceiverCipherDataJson: any;\r\n  };\r\n  responderContactCard?: KeyExchangeContactCardInput;\r\n}\r\n\r\nexport enum KeyExchangeState {\r\n  IN_PROGRESS = 'IN_PROGRESS',\r\n  COMPLETED = 'COMPLETED',\r\n  DECLINED = 'DECLINED',\r\n  CANCELLED = 'CANCELLED',\r\n}\r\n\r\nexport enum KeyExchangeMode {\r\n  OTK = 'OTK',\r\n}\r\n\r\nexport interface Otk {\r\n  id: string;\r\n  state: OtkState;\r\n  otKeyParams: string;\r\n  otKeyCipher: string;\r\n  sharedKey: Key;\r\n  mkSharedKey: Key;\r\n  initiatorSigPxk: Key;\r\n  responderSigPxk: Key;\r\n  // Encrypted\r\n  initiatorOneTimePbkCipher: string; // single time use public key created by the initiator.\r\n  responderPbkCipher?: string; // responderPbk is the long lived Pbk of the responder.\r\n}\r\n\r\nexport interface KeyExchange {\r\n  id: string;\r\n  state: KeyExchangeState;\r\n  mode: KeyExchangeMode;\r\n  created: string;\r\n  modified: string;\r\n  isInitiator: boolean;\r\n  initiator: {\r\n    id: string;\r\n    username: string;\r\n  };\r\n  responder: {\r\n    id: string;\r\n    username: string;\r\n  };\r\n  initiatorActionRequired?: boolean;\r\n  responderActionRequired?: boolean;\r\n  responderEmailAddress?: string;\r\n  token?: string;\r\n  tokenExpiryTime?: string;\r\n  isExpired?: boolean;\r\n  otk?: Otk;\r\n  initiatorRootKeyCipher: string;\r\n}\r\n\r\nexport interface DecryptedKeyExchange extends KeyExchange {\r\n  decryptedOtk?: DecryptedOtk;\r\n  message?: KeyExchangeMessage;\r\n  contactCard?: TrustedPartyDetails;\r\n  myMessage?: KeyExchangeMessage;\r\n  myContactCard?: TrustedPartyDetails;\r\n}\r\n\r\nexport interface GetKeyExchangeOptions {\r\n  // The otKey as a raw string. i.e. key.toJSON(true).k\r\n  otKeyK?: string;\r\n  // User need the token if they have not responded to the key exchange yet.\r\n  // Once they've responded (hence proven they have the OOB Key) they become\r\n  // the \"responder\" of this exchange, and can access it when signed in.\r\n  token?: string;\r\n}\r\n\r\nexport interface RespondOtk {\r\n  keyExchange: KeyExchange;\r\n  userSharedKey: UserSharedKey;\r\n  tp: {\r\n    id: string;\r\n  };\r\n}\r\n\r\nexport interface CompleteOtk {\r\n  keyExchange: KeyExchange;\r\n  userSharedKey: UserSharedKey;\r\n  tp: {\r\n    id: string;\r\n  };\r\n}\r\n\r\nexport interface UserSharedKey {\r\n  userSigPrk: Key;\r\n  sharedKey: Key;\r\n  mkSharedKey?: Key;\r\n  mkPxk?: Key;\r\n  mkReshareRequestCipher?: string;\r\n  mkReshareResponseCipher?: string;\r\n  mkReshareRequestSent?: boolean;\r\n  mkReshareResponseSent?: boolean;\r\n}\r\n\r\nexport interface GetKeyExchangeListOptions {\r\n  orderBy?:\r\n    | 'created'\r\n    | '-created'\r\n    | 'modified'\r\n    | '-modified'\r\n    | 'expiry_time'\r\n    | '-expiry_time';\r\n  isExpired?: boolean;\r\n  initiatorActionRequired?: boolean;\r\n  responderActionRequired?: boolean;\r\n  initiator?: string;\r\n  responder?: string;\r\n  state?: 'IN_PROGRESS' | 'COMPLETED' | 'DECLINED' | 'CANCELLED';\r\n}\r\n\r\nexport interface PlainResponderPbkCipher {\r\n  otKey: object;\r\n}\r\n"]}