@lifeready/core 1.0.21 → 1.0.22

package/esm2015/lib/shared-contact-card/shared-contact-card.service.js

@@ -0,0 +1,119 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import gql from 'graphql-tag';
+import { EncryptionService } from '../encryption/encryption.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { KeyService } from '../key/key.service';
+import { ContactCardName } from '../profile/profile.types';
+import { LrApolloService } from '../api/lr-apollo.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../key/key.service";
+import * as i2 from "../api/lr-apollo.service";
+import * as i3 from "../key/key-graph.service";
+import * as i4 from "../encryption/encryption.service";
+export const SharedContactCardFields = `
+  id
+  owner {
+    id
+    username
+  }
+  ownerKey {
+    id
+  }
+  ownerCipherData
+  receiver {
+    id
+    username
+  }
+  receiverKey {
+    id
+  }
+  receiverCipherData
+  sharedKey {
+    id
+  }
+  sharedCipherData
+  sharedCipherDataSig
+  sharedCipherDataSigPxk {
+    id
+  }
+`;
+const UpdateOwnedContactCard = gql `
+mutation UpdateOwnedContactCard(
+  $input: UpdateOwnedContactCardInput!
+) {
+  updateOwnedContactCard(
+    input: $input
+  ) {
+    ownedContactCard {
+      ${SharedContactCardFields}
+    }
+  }
+}`;
+export class SharedContactCardService {
+    constructor(keyService, lrApollo, keyGraph, encryptionService) {
+        this.keyService = keyService;
+        this.lrApollo = lrApollo;
+        this.keyGraph = keyGraph;
+        this.encryptionService = encryptionService;
+    }
+    decryptSharedTrustedPartyDetails(cc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const details = yield this.decryptTrustedPartyDetails(cc);
+            return Object.assign({ id: cc.id, ownedKeyId: cc.ownerKey.id, sharedKeyId: cc.sharedKey.id }, details);
+        });
+    }
+    decryptTrustedPartyDetails(cc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (cc && cc.sharedKey && cc.sharedCipherData) {
+                try {
+                    return yield this.encryptionService.decrypt(yield this.keyGraph.getJwkKey(cc.sharedKey.id), cc.sharedCipherData);
+                }
+                catch (e) {
+                    console.error('Cannot decrypt trusted party details', e);
+                }
+            }
+            return null;
+        });
+    }
+    updateMySharedContactCard(id, ownedKeyId, sharedKeyId, contactCard) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ownerKey = yield this.keyGraph.getKey(ownedKeyId);
+            const sharedKey = yield this.keyGraph.getKey(sharedKeyId);
+            const sigPxk = yield this.keyService.getCurrentSigPxk();
+            const sharedCipherData = yield this.encryptionService.encrypt(sharedKey.jwk, contactCard);
+            const sharedCipherDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, sharedCipherData));
+            const ownerPlainData = {
+                name: new ContactCardName(contactCard.name),
+            };
+            const ownerPlainDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, ownerPlainData));
+            yield this.lrApollo.mutate({
+                mutation: UpdateOwnedContactCard,
+                variables: {
+                    input: {
+                        id,
+                        ownerCipherData: '',
+                        ownerKeyId: ownerKey.id,
+                        sharedCipherDataSig,
+                        sharedKeyId: sharedKey.id,
+                        sigPxkId: sigPxk.id,
+                        ownerPlainDataSig,
+                    },
+                },
+            });
+        });
+    }
+}
+SharedContactCardService.ɵprov = i0.ɵɵdefineInjectable({ factory: function SharedContactCardService_Factory() { return new SharedContactCardService(i0.ɵɵinject(i1.KeyService), i0.ɵɵinject(i2.LrApolloService), i0.ɵɵinject(i3.KeyGraphService), i0.ɵɵinject(i4.EncryptionService)); }, token: SharedContactCardService, providedIn: "root" });
+SharedContactCardService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+SharedContactCardService.ctorParameters = () => [
+    { type: KeyService },
+    { type: LrApolloService },
+    { type: KeyGraphService },
+    { type: EncryptionService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared-contact-card.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/shared-contact-card/shared-contact-card.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport gql from 'graphql-tag';\nimport { EncryptionService } from '../encryption/encryption.service';\nimport { KeyGraphService } from '../key/key-graph.service';\nimport { KeyService } from '../key/key.service';\nimport { Key } from '../key/key.types';\nimport { ContactCardName, TrustedPartyDetails } from '../profile/profile.types';\nimport { SharedTrustedPartyDetails } from '../trusted-party/trusted-party.types';\nimport { User } from '../user/user.types';\nimport { LrApolloService } from '../api/lr-apollo.service';\nimport { JSONObject } from '../api/types';\n\nexport const SharedContactCardFields = `\n  id\n  owner {\n    id\n    username\n  }\n  ownerKey {\n    id\n  }\n  ownerCipherData\n  receiver {\n    id\n    username\n  }\n  receiverKey {\n    id\n  }\n  receiverCipherData\n  sharedKey {\n    id\n  }\n  sharedCipherData\n  sharedCipherDataSig\n  sharedCipherDataSigPxk {\n    id\n  }\n`;\n\nconst UpdateOwnedContactCard = gql`\nmutation UpdateOwnedContactCard(\n  $input: UpdateOwnedContactCardInput!\n) {\n  updateOwnedContactCard(\n    input: $input\n  ) {\n    ownedContactCard {\n      ${SharedContactCardFields}\n    }\n  }\n}`;\n\ninterface UpdateOwnedContactCard {\n  updateOwnedContactCard: {\n    ownedContactCard: SharedContactCard;\n  };\n}\n\nexport interface SharedContactCard {\n  id: string;\n  owner: User;\n  ownerKey: Key;\n  ownerCipherData: string;\n  receiver: User;\n  receiverKey: Key;\n  receiverCipherData: string;\n  sharedKey: Key;\n  sharedCipherData: string;\n  // Decrypted\n  plainOwnerCipherDataJson: JSONObject;\n  plainReceiverCipherDataJson: JSONObject;\n  plainSharedCipherDataJson: JSONObject;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SharedContactCardService {\n  constructor(\n    private keyService: KeyService,\n    private lrApollo: LrApolloService,\n    private keyGraph: KeyGraphService,\n    private encryptionService: EncryptionService\n  ) {}\n\n  async decryptSharedTrustedPartyDetails(\n    cc: SharedContactCard\n  ): Promise<SharedTrustedPartyDetails> {\n    const details = await this.decryptTrustedPartyDetails(cc);\n\n    return {\n      id: cc.id,\n      ownedKeyId: cc.ownerKey.id,\n      sharedKeyId: cc.sharedKey.id,\n      ...details,\n    };\n  }\n\n  async decryptTrustedPartyDetails(\n    cc: SharedContactCard\n  ): Promise<TrustedPartyDetails> {\n    if (cc && cc.sharedKey && cc.sharedCipherData) {\n      try {\n        return await this.encryptionService.decrypt(\n          await this.keyGraph.getJwkKey(cc.sharedKey.id),\n          cc.sharedCipherData\n        );\n      } catch (e) {\n        console.error('Cannot decrypt trusted party details', e);\n      }\n    }\n    return null;\n  }\n\n  async updateMySharedContactCard(\n    id: string,\n    ownedKeyId: string,\n    sharedKeyId: string,\n    contactCard: TrustedPartyDetails\n  ): Promise<void> {\n    const ownerKey = await this.keyGraph.getKey(ownedKeyId);\n    const sharedKey = await this.keyGraph.getKey(sharedKeyId);\n    const sigPxk = await this.keyService.getCurrentSigPxk();\n\n    const sharedCipherData = await this.encryptionService.encrypt(\n      sharedKey.jwk,\n      contactCard\n    );\n    const sharedCipherDataSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, sharedCipherData)\n    );\n\n    const ownerPlainData = {\n      name: new ContactCardName(contactCard.name),\n    };\n    const ownerPlainDataSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, ownerPlainData)\n    );\n\n    await this.lrApollo.mutate<UpdateOwnedContactCard>({\n      mutation: UpdateOwnedContactCard,\n      variables: {\n        input: {\n          id,\n          ownerCipherData: '',\n          ownerKeyId: ownerKey.id,\n          sharedCipherDataSig,\n          sharedKeyId: sharedKey.id,\n          sigPxkId: sigPxk.id,\n          ownerPlainDataSig,\n        },\n      },\n    });\n  }\n}\n"]}

package/esm2015/lib/shared-contact-card/shared-contact-card2.gql.js

@@ -0,0 +1,41 @@
+import { gqlTyped } from '../_common/ast';
+export const UpdateOwnedContactCardMutation = gqlTyped `
+mutation UpdateOwnedContactCardMutation(
+  $input: UpdateOwnedContactCardInput!
+) {
+  updateOwnedContactCard(input: $input) {
+    ownedContactCard {
+      id
+    }
+  }
+}`;
+export const UpdateReceivedContactCardMutation = gqlTyped `
+mutation UpdateReceivedContactCardMutation(
+  $input: UpdateReceivedContactCardInput!
+) {
+  updateReceivedContactCard(input: $input) {
+    receivedContactCard {
+      id
+    }
+  }
+}`;
+export const GetOwnedContactCardKeyIdsQuery = gqlTyped `
+query GetOwnedContactCardKeyIdsQuery($id: LrRelayIdInput!) {
+  ownedContactCard(id: $id) {
+    sharedKey {
+      id
+    }
+    ownerKey {
+      id
+    }
+  }
+}`;
+export const GetReceivedContactCardKeyIdQuery = gqlTyped `
+query GetReceivedContactCardKeyIdQuery($id: LrRelayIdInput!) {
+  receivedContactCard(id: $id) {
+    receiverKey {
+      id
+    }
+  }
+}`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/shared-contact-card/shared-contact-card2.service.js

@@ -0,0 +1,117 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, NgZone } from '@angular/core';
+import { LrGraphQLService, LrMutation } from '../api/lr-graphql';
+import { EncryptionService } from '../encryption/encryption.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { KeyService } from '../key/key.service';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import { GetOwnedContactCardKeyIdsQuery, GetReceivedContactCardKeyIdQuery, UpdateOwnedContactCardMutation, UpdateReceivedContactCardMutation, } from './shared-contact-card2.gql';
+import * as i0 from "@angular/core";
+import * as i1 from "../key/key.service";
+import * as i2 from "../key/key-graph.service";
+import * as i3 from "../encryption/encryption.service";
+import * as i4 from "../api/lr-graphql/lr-graphql.service";
+let SharedContactCard2Service = class SharedContactCard2Service {
+    constructor(ngZone, keyService, keyGraph, encryptionService, lrGraphQL) {
+        this.ngZone = ngZone;
+        this.keyService = keyService;
+        this.keyGraph = keyGraph;
+        this.encryptionService = encryptionService;
+        this.lrGraphQL = lrGraphQL;
+    }
+    getOwnedContactCardKeyIds(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { ownedContactCard: cc } = yield this.lrGraphQL.query({
+                query: GetOwnedContactCardKeyIdsQuery,
+                variables: {
+                    id,
+                },
+            });
+            return {
+                sharedKeyId: cc.sharedKey.id,
+                ownerKeyId: cc.ownerKey.id,
+            };
+        });
+    }
+    getReceivedContactCardKeyId(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.lrGraphQL.query({
+                query: GetReceivedContactCardKeyIdQuery,
+                variables: {
+                    id,
+                },
+            })).receivedContactCard.receiverKey.id;
+        });
+    }
+    updateOwnedContactCard({ id, ownerKeyId, sharedKeyId, ownerPlainDataJson, ownerCipherDataClearJson, sharedCipherDataClearJson, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let ownerKey;
+            let sharedKey;
+            try {
+                ownerKey = yield this.keyGraph.getKey(ownerKeyId);
+                sharedKey = yield this.keyGraph.getKey(sharedKeyId);
+            }
+            catch (error) {
+                const keys = yield this.getOwnedContactCardKeyIds(id);
+                // try again
+                ownerKey = yield this.keyGraph.getKey(keys.ownerKeyId);
+                sharedKey = yield this.keyGraph.getKey(keys.sharedKeyId);
+            }
+            const sigPxk = yield this.keyService.getCurrentSigPxk();
+            const sharedCipherData = yield this.encryptionService.encrypt(sharedKey.jwk, sharedCipherDataClearJson);
+            const sharedCipherDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, sharedCipherData));
+            const ownerPlainDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, ownerPlainDataJson));
+            const ownerCipherData = yield this.encryptionService.encryptToString(ownerKey.jwk, ownerCipherDataClearJson);
+            return new LrMutation({
+                mutation: UpdateOwnedContactCardMutation,
+                variables: {
+                    input: {
+                        id,
+                        ownerCipherData,
+                        ownerKeyId: ownerKey.id,
+                        sharedCipherDataSig,
+                        sharedKeyId: sharedKey.id,
+                        sigPxkId: sigPxk.id,
+                        ownerPlainDataSig,
+                    },
+                },
+            });
+        });
+    }
+    updateReceivedContactCard({ id, receiverKeyId, receiverCipherDataClearJson, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const receiverKey = yield this.keyGraph.getKey(receiverKeyId, () => this.getReceivedContactCardKeyId(id));
+            const receiverCipherData = yield this.encryptionService.encryptToString(receiverKey.jwk, receiverCipherDataClearJson);
+            return new LrMutation({
+                mutation: UpdateReceivedContactCardMutation,
+                variables: {
+                    input: {
+                        id,
+                        receiverCipherData,
+                        receiverKeyId: receiverKey.id,
+                    },
+                },
+            });
+        });
+    }
+};
+SharedContactCard2Service.ɵprov = i0.ɵɵdefineInjectable({ factory: function SharedContactCard2Service_Factory() { return new SharedContactCard2Service(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i1.KeyService), i0.ɵɵinject(i2.KeyGraphService), i0.ɵɵinject(i3.EncryptionService), i0.ɵɵinject(i4.LrGraphQLService)); }, token: SharedContactCard2Service, providedIn: "root" });
+SharedContactCard2Service.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+SharedContactCard2Service.ctorParameters = () => [
+    { type: NgZone },
+    { type: KeyService },
+    { type: KeyGraphService },
+    { type: EncryptionService },
+    { type: LrGraphQLService }
+];
+SharedContactCard2Service = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], SharedContactCard2Service);
+export { SharedContactCard2Service };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared-contact-card2.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/shared-contact-card/shared-contact-card2.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAKrE,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EACL,8BAA8B,EAC9B,gCAAgC,EAChC,8BAA8B,EAC9B,iCAAiC,GAClC,MAAM,4BAA4B,CAAC;;;;;;IAoBvB,yBAAyB,SAAzB,yBAAyB;IACpC,YACU,MAAc,EACd,UAAsB,EACtB,QAAyB,EACzB,iBAAoC,EACpC,SAA2B;QAJ3B,WAAM,GAAN,MAAM,CAAQ;QACd,eAAU,GAAV,UAAU,CAAY;QACtB,aAAQ,GAAR,QAAQ,CAAiB;QACzB,sBAAiB,GAAjB,iBAAiB,CAAmB;QACpC,cAAS,GAAT,SAAS,CAAkB;IAClC,CAAC;IAEU,yBAAyB,CAAC,EAAkB;;YACxD,MAAM,EAAE,gBAAgB,EAAE,EAAE,EAAE,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;gBAC1D,KAAK,EAAE,8BAA8B;gBACrC,SAAS,EAAE;oBACT,EAAE;iBACH;aACF,CAAC,CAAC;YAEH,OAAO;gBACL,WAAW,EAAE,EAAE,CAAC,SAAS,CAAC,EAAE;gBAC5B,UAAU,EAAE,EAAE,CAAC,QAAQ,CAAC,EAAE;aAC3B,CAAC;QACJ,CAAC;KAAA;IAEa,2BAA2B,CAAC,EAAkB;;YAC1D,OAAO,CACL,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;gBACzB,KAAK,EAAE,gCAAgC;gBACvC,SAAS,EAAE;oBACT,EAAE;iBACH;aACF,CAAC,CACH,CAAC,mBAAmB,CAAC,WAAW,CAAC,EAAE,CAAC;QACvC,CAAC;KAAA;IAEK,sBAAsB,CAAC,EAC3B,EAAE,EACF,UAAU,EACV,WAAW,EACX,kBAAkB,EAClB,wBAAwB,EACxB,yBAAyB,GACG;;YAC5B,IAAI,QAAa,CAAC;YAClB,IAAI,SAAc,CAAC;YAEnB,IAAI;gBACF,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;gBAClD,SAAS,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;aACrD;YAAC,OAAO,KAAK,EAAE;gBACd,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,yBAAyB,CAAC,EAAE,CAAC,CAAC;gBAEtD,YAAY;gBACZ,QAAQ,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gBACvD,SAAS,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;aAC1D;YAED,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,gBAAgB,EAAE,CAAC;YAExD,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAC3D,SAAS,CAAC,GAAG,EACb,yBAAyB,CAC1B,CAAC;YACF,MAAM,mBAAmB,GAAG,IAAI,CAAC,SAAS,CACxC,MAAM,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAChE,CAAC;YAEF,MAAM,iBAAiB,GAAG,IAAI,CAAC,SAAS,CACtC,MAAM,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAClE,CAAC;YAEF,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CAClE,QAAQ,CAAC,GAAG,EACZ,wBAAwB,CACzB,CAAC;YAEF,OAAO,IAAI,UAAU,CAAC;gBACpB,QAAQ,EAAE,8BAA8B;gBACxC,SAAS,EAAE;oBACT,KAAK,EAAE;wBACL,EAAE;wBACF,eAAe;wBACf,UAAU,EAAE,QAAQ,CAAC,EAAE;wBACvB,mBAAmB;wBACnB,WAAW,EAAE,SAAS,CAAC,EAAE;wBACzB,QAAQ,EAAE,MAAM,CAAC,EAAE;wBACnB,iBAAiB;qBAClB;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAEK,yBAAyB,CAAC,EAC9B,EAAE,EACF,aAAa,EACb,2BAA2B,GACI;;YAC/B,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,aAAa,EAAE,GAAG,EAAE,CACjE,IAAI,CAAC,2BAA2B,CAAC,EAAE,CAAC,CACrC,CAAC;YAEF,MAAM,kBAAkB,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,eAAe,CACrE,WAAW,CAAC,GAAG,EACf,2BAA2B,CAC5B,CAAC;YAEF,OAAO,IAAI,UAAU,CAAC;gBACpB,QAAQ,EAAE,iCAAiC;gBAC3C,SAAS,EAAE;oBACT,KAAK,EAAE;wBACL,EAAE;wBACF,kBAAkB;wBAClB,aAAa,EAAE,WAAW,CAAC,EAAE;qBAC9B;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;CACF,CAAA;;;YAvHA,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;YApCoB,MAAM;YASlB,UAAU;YADV,eAAe;YALf,iBAAiB;YAFjB,gBAAgB;;AAoCZ,yBAAyB;IANrC,iBAAiB,CAAC;QACjB,UAAU,EAAE,QAAQ;KACrB,CAAC;GAIW,yBAAyB,CAoHrC;SApHY,yBAAyB","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\nimport { LrGraphQLService, LrMutation } from '../api/lr-graphql';\nimport { LrRelayIdInput } from '../api/types';\nimport { EncryptionService } from '../encryption/encryption.service';\nimport {\n  ContactCardReceiverCipherData,\n  SendContactCardInput,\n} from '../key-exchange/key-exchange2.service';\nimport { KeyGraphService } from '../key/key-graph.service';\nimport { KeyService } from '../key/key.service';\nimport { Key } from '../key/key.types';\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\nimport {\n  GetOwnedContactCardKeyIdsQuery,\n  GetReceivedContactCardKeyIdQuery,\n  UpdateOwnedContactCardMutation,\n  UpdateReceivedContactCardMutation,\n} from './shared-contact-card2.gql';\n\nexport interface UpdateOwnedContactCardInput extends SendContactCardInput {\n  id: LrRelayIdInput;\n  ownerKeyId?: LrRelayIdInput;\n  sharedKeyId?: LrRelayIdInput;\n}\n\nexport interface UpdateReceivedContactCardInput\n  extends ContactCardReceiverCipherData {\n  id: LrRelayIdInput;\n  receiverKeyId?: LrRelayIdInput;\n}\n\n@RunOutsideAngular({\n  ngZoneName: 'ngZone',\n})\n@Injectable({\n  providedIn: 'root',\n})\nexport class SharedContactCard2Service {\n  constructor(\n    private ngZone: NgZone,\n    private keyService: KeyService,\n    private keyGraph: KeyGraphService,\n    private encryptionService: EncryptionService,\n    private lrGraphQL: LrGraphQLService\n  ) {}\n\n  private async getOwnedContactCardKeyIds(id: LrRelayIdInput) {\n    const { ownedContactCard: cc } = await this.lrGraphQL.query({\n      query: GetOwnedContactCardKeyIdsQuery,\n      variables: {\n        id,\n      },\n    });\n\n    return {\n      sharedKeyId: cc.sharedKey.id,\n      ownerKeyId: cc.ownerKey.id,\n    };\n  }\n\n  private async getReceivedContactCardKeyId(id: LrRelayIdInput) {\n    return (\n      await this.lrGraphQL.query({\n        query: GetReceivedContactCardKeyIdQuery,\n        variables: {\n          id,\n        },\n      })\n    ).receivedContactCard.receiverKey.id;\n  }\n\n  async updateOwnedContactCard({\n    id,\n    ownerKeyId,\n    sharedKeyId,\n    ownerPlainDataJson,\n    ownerCipherDataClearJson,\n    sharedCipherDataClearJson,\n  }: UpdateOwnedContactCardInput) {\n    let ownerKey: Key;\n    let sharedKey: Key;\n\n    try {\n      ownerKey = await this.keyGraph.getKey(ownerKeyId);\n      sharedKey = await this.keyGraph.getKey(sharedKeyId);\n    } catch (error) {\n      const keys = await this.getOwnedContactCardKeyIds(id);\n\n      // try again\n      ownerKey = await this.keyGraph.getKey(keys.ownerKeyId);\n      sharedKey = await this.keyGraph.getKey(keys.sharedKeyId);\n    }\n\n    const sigPxk = await this.keyService.getCurrentSigPxk();\n\n    const sharedCipherData = await this.encryptionService.encrypt(\n      sharedKey.jwk,\n      sharedCipherDataClearJson\n    );\n    const sharedCipherDataSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, sharedCipherData)\n    );\n\n    const ownerPlainDataSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, ownerPlainDataJson)\n    );\n\n    const ownerCipherData = await this.encryptionService.encryptToString(\n      ownerKey.jwk,\n      ownerCipherDataClearJson\n    );\n\n    return new LrMutation({\n      mutation: UpdateOwnedContactCardMutation,\n      variables: {\n        input: {\n          id,\n          ownerCipherData,\n          ownerKeyId: ownerKey.id,\n          sharedCipherDataSig,\n          sharedKeyId: sharedKey.id,\n          sigPxkId: sigPxk.id,\n          ownerPlainDataSig,\n        },\n      },\n    });\n  }\n\n  async updateReceivedContactCard({\n    id,\n    receiverKeyId,\n    receiverCipherDataClearJson,\n  }: UpdateReceivedContactCardInput) {\n    const receiverKey = await this.keyGraph.getKey(receiverKeyId, () =>\n      this.getReceivedContactCardKeyId(id)\n    );\n\n    const receiverCipherData = await this.encryptionService.encryptToString(\n      receiverKey.jwk,\n      receiverCipherDataClearJson\n    );\n\n    return new LrMutation({\n      mutation: UpdateReceivedContactCardMutation,\n      variables: {\n        input: {\n          id,\n          receiverCipherData,\n          receiverKeyId: receiverKey.id,\n        },\n      },\n    });\n  }\n}\n"]}

package/esm2015/lib/slip39/slip39.service.js

@@ -0,0 +1,169 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { Slip39, Slip39Helper } from 'slip39';
+import * as i0 from "@angular/core";
+export class SecretShare {
+    constructor(assembly = 0, subAssembly = 0, mnemonics = '') {
+        this.assembly = assembly;
+        this.subAssembly = subAssembly;
+        this.mnemonics = mnemonics;
+    }
+}
+export class SubAssembly {
+    constructor(index, threshold = 0, size = 0) {
+        this.index = index;
+        this.threshold = threshold;
+        this.size = size;
+        this.clearShares();
+    }
+    clearShares() {
+        this.shares = Array();
+    }
+    addShare(share) {
+        this.shares.push(share);
+    }
+}
+export class Assembly {
+    constructor(threshold = 0) {
+        this.threshold = threshold;
+        this.clearSubAssemblies();
+    }
+    size() {
+        return this.subAssemblies.length;
+    }
+    clearSubAssemblies() {
+        this.subAssemblies = new Array();
+    }
+    addSubAssembly(subAssembly) {
+        this.subAssemblies.push(subAssembly);
+    }
+}
+export class SubQuorum {
+    constructor(subAssemblyIndex) {
+        this.subAssemblyIndex = subAssemblyIndex;
+        this.clearShares();
+    }
+    clearShares() {
+        this.shares = new Array();
+    }
+    addShare(share) {
+        this.shares.push(share);
+    }
+}
+export class Quorum {
+    constructor() {
+        this.clearSubQuora();
+    }
+    clearSubQuora() {
+        this.subQuora = new Array();
+    }
+    addSubQuorum(subQuorum) {
+        this.subQuora.push(subQuorum);
+    }
+    serialiseShares() {
+        let shares = [];
+        this.subQuora.forEach((subQuorum) => {
+            shares = shares.concat(subQuorum.shares);
+        });
+        return shares;
+    }
+}
+export class Slip39Service {
+    constructor() { }
+    generateShares(secret, passphrase, assembly) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Hex-encode secret.
+            let ems = btoa(secret);
+            ems = Slip39Helper.slip39EncodeHex(ems);
+            // Construct group specifications
+            const groups = [];
+            for (const sa of assembly.subAssemblies) {
+                groups.push([sa.threshold, sa.size]);
+            }
+            // Split!
+            const slip = yield Slip39.fromArray(ems, {
+                passphrase,
+                threshold: assembly.threshold,
+                groups,
+                title: '',
+            });
+            // Extract shares
+            assembly.subAssemblies.forEach((sa, isa) => {
+                // Remove any existing shares
+                sa.clearShares();
+                for (let im = 0; im < sa.size; im++) {
+                    // Construct the path to the share, formatted as "r/<subassembly index>/<member index>"
+                    // with <subassembly index> and <member index> being two-digit, zero-padded integers.
+                    const path = 'r/' +
+                        isa.toString().padStart(2, '0') +
+                        '/' +
+                        im.toString().padStart(2, '0');
+                    const mnemonics = slip.fromPath(path).mnemonics[0];
+                    const share = new SecretShare(isa, im, mnemonics);
+                    sa.addShare(share);
+                }
+            });
+        });
+    }
+    // Remove all redundant shares. i.e. keep only enough members and groups to satisfy the thresholds.
+    minimalSet(mnemonics) {
+        // Decode the mnemonics and sort then into groups.
+        let groupThresh = null;
+        const groups = new Map();
+        for (const mnemonic of mnemonics) {
+            const decoded = Slip39Helper.decodeMnemonic(mnemonic);
+            if (groupThresh && groupThresh !== decoded.groupThreshold) {
+                throw new Error('groupThreshold is different in mnemonics');
+            }
+            groupThresh = decoded.groupThreshold;
+            // Note that Slip39.recoverSecret() will do all the error checking again. So it's not critical
+            // that we error check here. So we just optimistically assume it's all good.
+            let g = groups.get(decoded.groupIndex);
+            if (g == null) {
+                g = {
+                    memberThreshold: decoded.memberThreshold,
+                    members: [],
+                };
+                groups.set(decoded.groupIndex, g);
+            }
+            g.members.push({
+                mnemonic,
+                decoded,
+            });
+        }
+        // Keep the minimum set of groups that meet threshold.
+        const mnemonicsMinSet = [];
+        let groupCount = 0;
+        for (const g of groups.values()) {
+            // Keep only groups that meet threshold
+            if (g.members.length < g.memberThreshold) {
+                continue;
+            }
+            // Keep minimum number of approvals needed for group
+            g.members.slice(0, g.memberThreshold).forEach((member) => {
+                mnemonicsMinSet.push(member.mnemonic);
+            });
+            ++groupCount;
+            if (groupCount >= groupThresh) {
+                break;
+            }
+        }
+        return mnemonicsMinSet;
+    }
+    recoverSecret(shares, passphrase) {
+        return __awaiter(this, void 0, void 0, function* () {
+            shares = this.minimalSet(shares);
+            const recovered = yield Slip39.recoverSecret(shares, passphrase);
+            const secret = Slip39Helper.slip39DecodeHex(recovered);
+            return atob(secret);
+        });
+    }
+}
+Slip39Service.ɵprov = i0.ɵɵdefineInjectable({ factory: function Slip39Service_Factory() { return new Slip39Service(); }, token: Slip39Service, providedIn: "root" });
+Slip39Service.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+Slip39Service.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slip39.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/slip39/slip39.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Slip39, Slip39Helper } from 'slip39';\n\nexport class SecretShare {\n  constructor(\n    public assembly: number = 0,\n    public subAssembly: number = 0,\n    public mnemonics: string = ''\n  ) {}\n}\n\nexport class SubAssembly {\n  constructor(\n    public index: number,\n    public threshold: number = 0,\n    public size: number = 0\n  ) {\n    this.clearShares();\n  }\n\n  shares: SecretShare[];\n\n  public clearShares() {\n    this.shares = Array();\n  }\n\n  public addShare(share: SecretShare) {\n    this.shares.push(share);\n  }\n}\n\nexport class Assembly {\n  constructor(public threshold: number = 0) {\n    this.clearSubAssemblies();\n  }\n\n  subAssemblies: SubAssembly[];\n\n  public size() {\n    return this.subAssemblies.length;\n  }\n\n  public clearSubAssemblies() {\n    this.subAssemblies = new Array();\n  }\n\n  public addSubAssembly(subAssembly: SubAssembly) {\n    this.subAssemblies.push(subAssembly);\n  }\n}\n\nexport class SubQuorum {\n  shares: string[];\n\n  constructor(public subAssemblyIndex: number) {\n    this.clearShares();\n  }\n\n  public clearShares() {\n    this.shares = new Array();\n  }\n\n  public addShare(share: string) {\n    this.shares.push(share);\n  }\n}\n\nexport class Quorum {\n  subQuora: SubQuorum[];\n\n  constructor() {\n    this.clearSubQuora();\n  }\n\n  public clearSubQuora() {\n    this.subQuora = new Array();\n  }\n\n  public addSubQuorum(subQuorum: SubQuorum) {\n    this.subQuora.push(subQuorum);\n  }\n\n  public serialiseShares() {\n    let shares = [];\n\n    this.subQuora.forEach((subQuorum) => {\n      shares = shares.concat(subQuorum.shares);\n    });\n\n    return shares;\n  }\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class Slip39Service {\n  constructor() {}\n\n  public async generateShares(secret, passphrase: string, assembly: Assembly) {\n    // Hex-encode secret.\n    let ems = btoa(secret);\n    ems = Slip39Helper.slip39EncodeHex(ems);\n\n    // Construct group specifications\n    const groups = [];\n\n    for (const sa of assembly.subAssemblies) {\n      groups.push([sa.threshold, sa.size]);\n    }\n\n    // Split!\n    const slip = await Slip39.fromArray(ems, {\n      passphrase,\n      threshold: assembly.threshold,\n      groups,\n      title: '',\n    });\n\n    // Extract shares\n    assembly.subAssemblies.forEach((sa, isa) => {\n      // Remove any existing shares\n      sa.clearShares();\n\n      for (let im = 0; im < sa.size; im++) {\n        // Construct the path to the share, formatted as \"r/<subassembly index>/<member index>\"\n        // with <subassembly index> and <member index> being two-digit, zero-padded integers.\n        const path =\n          'r/' +\n          isa.toString().padStart(2, '0') +\n          '/' +\n          im.toString().padStart(2, '0');\n        const mnemonics = slip.fromPath(path).mnemonics[0];\n        const share = new SecretShare(isa, im, mnemonics);\n\n        sa.addShare(share);\n      }\n    });\n  }\n\n  // Remove all redundant shares. i.e. keep only enough members and groups to satisfy the thresholds.\n  private minimalSet(mnemonics: string[]): string[] {\n    // Decode the mnemonics and sort then into groups.\n    let groupThresh = null;\n    const groups = new Map();\n    for (const mnemonic of mnemonics) {\n      const decoded = Slip39Helper.decodeMnemonic(mnemonic);\n\n      if (groupThresh && groupThresh !== decoded.groupThreshold) {\n        throw new Error('groupThreshold is different in mnemonics');\n      }\n\n      groupThresh = decoded.groupThreshold;\n\n      // Note that Slip39.recoverSecret() will do all the error checking again. So it's not critical\n      // that we error check here. So we just optimistically assume it's all good.\n      let g = groups.get(decoded.groupIndex);\n      if (g == null) {\n        g = {\n          memberThreshold: decoded.memberThreshold,\n          members: [],\n        };\n        groups.set(decoded.groupIndex, g);\n      }\n\n      g.members.push({\n        mnemonic,\n        decoded,\n      });\n    }\n\n    // Keep the minimum set of groups that meet threshold.\n    const mnemonicsMinSet = [];\n    let groupCount = 0;\n    for (const g of groups.values()) {\n      // Keep only groups that meet threshold\n      if (g.members.length < g.memberThreshold) {\n        continue;\n      }\n\n      // Keep minimum number of approvals needed for group\n      g.members.slice(0, g.memberThreshold).forEach((member) => {\n        mnemonicsMinSet.push(member.mnemonic);\n      });\n\n      ++groupCount;\n      if (groupCount >= groupThresh) {\n        break;\n      }\n    }\n\n    return mnemonicsMinSet;\n  }\n\n  public async recoverSecret(shares: string[], passphrase: string) {\n    shares = this.minimalSet(shares);\n\n    const recovered = await Slip39.recoverSecret(shares, passphrase);\n\n    const secret = Slip39Helper.slip39DecodeHex(recovered);\n\n    return atob(secret);\n  }\n}\n"]}