@lifeready/core 1.0.21 → 1.0.22

package/esm2015/lib/message/message.service.js

@@ -0,0 +1,116 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, Injector, NgZone } from '@angular/core';
+import { LrMutation, LrService } from '../api/lr-graphql';
+import { EncryptionService } from '../encryption/encryption.service';
+import { KeyExchangeService } from '../key-exchange/key-exchange.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import { MessageQuery, SendMessageMutation } from './message.gql';
+import * as i0 from "@angular/core";
+import * as i1 from "../key/key-graph.service";
+import * as i2 from "../encryption/encryption.service";
+import * as i3 from "../key-exchange/key-exchange.service";
+let MessageService = class MessageService extends LrService {
+    constructor(ngZone, injector, keyGraph, encryptionService, keyExchangeService) {
+        super(injector);
+        this.ngZone = ngZone;
+        this.injector = injector;
+        this.keyGraph = keyGraph;
+        this.encryptionService = encryptionService;
+        this.keyExchangeService = keyExchangeService;
+        this.encrypt = this.encryptionService.encrypt.bind(this.encryptionService);
+        this.decrypt = this.encryptionService.decrypt.bind(this.encryptionService);
+        this.sign = this.encryptionService.sign.bind(this.encryptionService);
+        this.verify = this.encryptionService.verify.bind(this.encryptionService);
+    }
+    sendMessage(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mutate(this.sendMessageMutation(input));
+        });
+    }
+    sendMessageMutation({ username, userId, plainMessageJson, plainCipherMessageJson, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userSharedKey = yield this.keyExchangeService.currentUserSharedKey({
+                username,
+                userId,
+            });
+            const input = {
+                receiverUsername: username,
+                receiverId: userId,
+                sharedKeyId: userSharedKey.sharedKey.id,
+                senderSigPbkId: userSharedKey.userSigPrk.id,
+            };
+            if (plainCipherMessageJson) {
+                const sharedKey = yield this.keyGraph.getJwkKey(userSharedKey.sharedKey.id);
+                const cipherMessage = yield this.encrypt(sharedKey, plainCipherMessageJson);
+                const senderSigPrk = yield this.keyGraph.getJwkKey(userSharedKey.userSigPrk.id);
+                const signedCipherMessage = yield this.sign(senderSigPrk, cipherMessage);
+                input.signedCipherMessage = JSON.stringify(signedCipherMessage);
+            }
+            if (plainMessageJson) {
+                input.plainMessage = JSON.stringify(plainMessageJson);
+            }
+            return new LrMutation({
+                mutation: SendMessageMutation,
+                variables: {
+                    input,
+                },
+            });
+        });
+    }
+    decryptMessage(message, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signedCipherMessage = yield this.verify(options.senderSigPbk, JSON.parse(message.signedCipherMessage));
+            message.signedCipherMessageClearJson = yield this.decrypt(options.sharedKey, signedCipherMessage);
+        });
+    }
+    getMessage(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.query({
+                query: MessageQuery,
+                variables: {
+                    id,
+                },
+            });
+            // this.keyGraph.addKeys(res.keyGraph);
+            const message = res.message;
+            const sharedKey = yield this.keyGraph.getJwkKey(message.sharedKey.id);
+            // The sender would be getting the Prk back. The receiver gets the Pbk back.
+            // But only the Pbk is needed here to verify signature.
+            // So both sender and receiver can access this message.
+            const senderSigPbk = yield this.keyGraph.getJwkKey(message.senderSigPbk.id);
+            // Test bad signature
+            // senderSigPbk = senderSigPbk.toJSON();
+            // senderSigPbk.n = "x" + senderSigPbk.n.substring(1);
+            // senderSigPbk = await KFS.asKey(senderSigPbk);
+            yield this.decryptMessage(message, {
+                sharedKey,
+                senderSigPbk,
+            });
+            if (message.plainMessage) {
+                message.plainMessageJson = JSON.parse(message.plainMessage);
+            }
+            return res.message;
+        });
+    }
+};
+MessageService.ɵprov = i0.ɵɵdefineInjectable({ factory: function MessageService_Factory() { return new MessageService(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i1.KeyGraphService), i0.ɵɵinject(i2.EncryptionService), i0.ɵɵinject(i3.KeyExchangeService)); }, token: MessageService, providedIn: "root" });
+MessageService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+MessageService.ctorParameters = () => [
+    { type: NgZone },
+    { type: Injector },
+    { type: KeyGraphService },
+    { type: EncryptionService },
+    { type: KeyExchangeService }
+];
+MessageService = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], MessageService);
+export { MessageService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/message/message.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector, NgZone } from '@angular/core';\nimport { JWK } from 'node-jose';\nimport { LrMutation, LrService } from '../api/lr-graphql';\nimport { MessageNode } from '../api/types';\nimport { EncryptionService } from '../encryption/encryption.service';\nimport { KeyExchangeService } from '../key-exchange/key-exchange.service';\nimport { KeyGraphService } from '../key/key-graph.service';\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\nimport { MessageQuery, SendMessageMutation } from './message.gql';\nimport { SendMessageInput } from './message.types';\n\n@RunOutsideAngular({\n  ngZoneName: 'ngZone',\n})\n@Injectable({\n  providedIn: 'root',\n})\nexport class MessageService extends LrService {\n  private readonly encrypt = this.encryptionService.encrypt.bind(\n    this.encryptionService\n  );\n  private readonly decrypt = this.encryptionService.decrypt.bind(\n    this.encryptionService\n  );\n  private readonly sign = this.encryptionService.sign.bind(\n    this.encryptionService\n  );\n  private readonly verify = this.encryptionService.verify.bind(\n    this.encryptionService\n  );\n\n  constructor(\n    private ngZone: NgZone,\n    private injector: Injector,\n    private keyGraph: KeyGraphService,\n    private encryptionService: EncryptionService,\n    private keyExchangeService: KeyExchangeService\n  ) {\n    super(injector);\n  }\n\n  async sendMessage(input: SendMessageInput) {\n    return this.mutate(this.sendMessageMutation(input));\n  }\n\n  async sendMessageMutation({\n    username,\n    userId,\n    plainMessageJson,\n    plainCipherMessageJson,\n  }: SendMessageInput) {\n    const userSharedKey = await this.keyExchangeService.currentUserSharedKey({\n      username,\n      userId,\n    });\n\n    const input: any = {\n      receiverUsername: username,\n      receiverId: userId,\n      sharedKeyId: userSharedKey.sharedKey.id,\n      senderSigPbkId: userSharedKey.userSigPrk.id,\n    };\n\n    if (plainCipherMessageJson) {\n      const sharedKey = await this.keyGraph.getJwkKey(\n        userSharedKey.sharedKey.id\n      );\n      const cipherMessage = await this.encrypt(\n        sharedKey,\n        plainCipherMessageJson\n      );\n\n      const senderSigPrk = await this.keyGraph.getJwkKey(\n        userSharedKey.userSigPrk.id\n      );\n      const signedCipherMessage = await this.sign(senderSigPrk, cipherMessage);\n\n      input.signedCipherMessage = JSON.stringify(signedCipherMessage);\n    }\n\n    if (plainMessageJson) {\n      input.plainMessage = JSON.stringify(plainMessageJson);\n    }\n\n    return new LrMutation({\n      mutation: SendMessageMutation,\n      variables: {\n        input,\n      },\n    });\n  }\n\n  async decryptMessage(\n    message: MessageNode,\n    options: { sharedKey: JWK.Key; senderSigPbk: JWK.Key }\n  ): Promise<void> {\n    const signedCipherMessage = await this.verify(\n      options.senderSigPbk,\n      JSON.parse(message.signedCipherMessage)\n    );\n\n    message.signedCipherMessageClearJson = await this.decrypt(\n      options.sharedKey,\n      signedCipherMessage\n    );\n  }\n\n  async getMessage(id: string) {\n    const res = await this.query({\n      query: MessageQuery,\n      variables: {\n        id,\n      },\n    });\n\n    // this.keyGraph.addKeys(res.keyGraph);\n\n    const message = res.message;\n\n    const sharedKey = await this.keyGraph.getJwkKey(message.sharedKey.id);\n\n    // The sender would be getting the Prk back. The receiver gets the Pbk back.\n    // But only the Pbk is needed here to verify signature.\n    // So both sender and receiver can access this message.\n    const senderSigPbk = await this.keyGraph.getJwkKey(message.senderSigPbk.id);\n\n    // Test bad signature\n    // senderSigPbk = senderSigPbk.toJSON();\n    // senderSigPbk.n = \"x\" + senderSigPbk.n.substring(1);\n    // senderSigPbk = await KFS.asKey(senderSigPbk);\n\n    await this.decryptMessage(message, {\n      sharedKey,\n      senderSigPbk,\n    });\n\n    if (message.plainMessage) {\n      message.plainMessageJson = JSON.parse(message.plainMessage);\n    }\n\n    return res.message;\n  }\n}\n"]}

package/esm2015/lib/message/message.types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZS50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIvb3B0L2F0bGFzc2lhbi9waXBlbGluZXMvYWdlbnQvYnVpbGQvcHJvamVjdHMvY29yZS9zcmMvIiwic291cmNlcyI6WyJsaWIvbWVzc2FnZS9tZXNzYWdlLnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBKV0sgfSBmcm9tICdub2RlLWpvc2UnO1xuaW1wb3J0IHsgSlNPTk9iamVjdCB9IGZyb20gJy4uL2FwaS90eXBlcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2VuZE1lc3NhZ2VJbnB1dCB7XG4gIHVzZXJuYW1lPzogc3RyaW5nO1xuICB1c2VySWQ/OiBzdHJpbmc7XG4gIHBsYWluTWVzc2FnZUpzb24/OiBKU09OT2JqZWN0O1xuICBwbGFpbkNpcGhlck1lc3NhZ2VKc29uPzogSlNPTk9iamVjdDtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBEZWNyeXB0TWVzc2FnZU9wdGlvbnMge1xuICBzaGFyZWRLZXk6IEpXSy5LZXk7XG4gIHNlbmRlclNpZ1BiazogSldLLktleTtcbn1cbiJdfQ==

package/esm2015/lib/password/password.gql.js

@@ -0,0 +1,28 @@
+import gql from 'graphql-tag';
+export const PasswordChangeRequestMutation = gql `
+  mutation {
+    passwordChangeRequest(input: {}) {
+      challenge
+    }
+  }
+`;
+export const PasswordChangeMutation = gql `
+  mutation PasswordChange($input: PasswordChangeInput!) {
+    passwordChange(input: $input) {
+      token
+      newPassKey {
+        id
+      }
+    }
+  }
+`;
+export const PasswordChangeConfigQuery = gql `
+  query PasswordChangeConfigQuery {
+    passwordChangeConfig {
+      maxAuthAgeSeconds
+      authTime
+      serverTime
+    }
+  }
+`;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFzc3dvcmQuZ3FsLmpzIiwic291cmNlUm9vdCI6Ii9vcHQvYXRsYXNzaWFuL3BpcGVsaW5lcy9hZ2VudC9idWlsZC9wcm9qZWN0cy9jb3JlL3NyYy8iLCJzb3VyY2VzIjpbImxpYi9wYXNzd29yZC9wYXNzd29yZC5ncWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxHQUFHLE1BQU0sYUFBYSxDQUFDO0FBRTlCLE1BQU0sQ0FBQyxNQUFNLDZCQUE2QixHQUFHLEdBQUcsQ0FBQTs7Ozs7O0NBTS9DLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxHQUFHLENBQUE7Ozs7Ozs7OztDQVN4QyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQUcsR0FBRyxDQUFBOzs7Ozs7OztDQVEzQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGdxbCBmcm9tICdncmFwaHFsLXRhZyc7XG5cbmV4cG9ydCBjb25zdCBQYXNzd29yZENoYW5nZVJlcXVlc3RNdXRhdGlvbiA9IGdxbGBcbiAgbXV0YXRpb24ge1xuICAgIHBhc3N3b3JkQ2hhbmdlUmVxdWVzdChpbnB1dDoge30pIHtcbiAgICAgIGNoYWxsZW5nZVxuICAgIH1cbiAgfVxuYDtcblxuZXhwb3J0IGNvbnN0IFBhc3N3b3JkQ2hhbmdlTXV0YXRpb24gPSBncWxgXG4gIG11dGF0aW9uIFBhc3N3b3JkQ2hhbmdlKCRpbnB1dDogUGFzc3dvcmRDaGFuZ2VJbnB1dCEpIHtcbiAgICBwYXNzd29yZENoYW5nZShpbnB1dDogJGlucHV0KSB7XG4gICAgICB0b2tlblxuICAgICAgbmV3UGFzc0tleSB7XG4gICAgICAgIGlkXG4gICAgICB9XG4gICAgfVxuICB9XG5gO1xuXG5leHBvcnQgY29uc3QgUGFzc3dvcmRDaGFuZ2VDb25maWdRdWVyeSA9IGdxbGBcbiAgcXVlcnkgUGFzc3dvcmRDaGFuZ2VDb25maWdRdWVyeSB7XG4gICAgcGFzc3dvcmRDaGFuZ2VDb25maWcge1xuICAgICAgbWF4QXV0aEFnZVNlY29uZHNcbiAgICAgIGF1dGhUaW1lXG4gICAgICBzZXJ2ZXJUaW1lXG4gICAgfVxuICB9XG5gO1xuIl19

package/esm2015/lib/password/password.service.js

@@ -0,0 +1,315 @@
+import { __awaiter } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import * as moment_ from 'moment';
+import { EncryptionService } from '../encryption/encryption.service';
+import { IdleService } from '../idle/idle.service';
+import { KeyFactoryService as KFS } from '../key/key-factory.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { LR_CONFIG } from '../life-ready.config';
+import { ProfileService } from '../profile/profile.service';
+import { WebCryptoService } from '../web-crypto/web-crypto.service';
+import { LrAuthException } from '../_common/exceptions';
+import { LrApolloService } from './../api/lr-apollo.service';
+import { PasswordChangeConfigQuery, PasswordChangeMutation, PasswordChangeRequestMutation, } from './password.gql';
+import * as i0 from "@angular/core";
+import * as i1 from "../life-ready.config";
+import * as i2 from "@angular/common/http";
+import * as i3 from "../api/lr-apollo.service";
+import * as i4 from "@aws-amplify/auth/lib-esm/Auth";
+import * as i5 from "../profile/profile.service";
+import * as i6 from "../key/key-factory.service";
+import * as i7 from "../encryption/encryption.service";
+import * as i8 from "../key/key-graph.service";
+import * as i9 from "../web-crypto/web-crypto.service";
+import * as i10 from "../idle/idle.service";
+// "why?" you ask: https://stackoverflow.com/questions/59735280/angular-8-moment-error-cannot-call-a-namespace-moment
+const moment = moment_;
+export class PasswordCheck {
+}
+export class PasswordService {
+    constructor(config, http, apollo, auth, profileService, keyFactory, encryptionService, keyGraph, webCryptoService, idleService) {
+        this.config = config;
+        this.http = http;
+        this.apollo = apollo;
+        this.auth = auth;
+        this.profileService = profileService;
+        this.keyFactory = keyFactory;
+        this.encryptionService = encryptionService;
+        this.keyGraph = keyGraph;
+        this.webCryptoService = webCryptoService;
+        this.idleService = idleService;
+        this.CLIENT_NONCE_LENGTH = 32;
+    }
+    checkPassword(password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { years } = this.passwordStrength(password);
+            return {
+                length: password.length,
+                timeToCrack: moment.duration({ years }),
+                passwordExposed: yield this.getExposureCount(password),
+            };
+        });
+    }
+    getExposureCount(password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sha1Password = yield this.webCryptoService.stringDigest('SHA-1', password);
+            const first5sha1 = sha1Password.substring(0, 5);
+            const response = yield this.http
+                .get(`https://api.pwnedpasswords.com/range/${first5sha1}`, {
+                responseType: 'text',
+            })
+                .toPromise();
+            const results = new RegExp(`^(?:${sha1Password.substring(5)}:)(?<count>\\d+)$`, 'im').exec(response);
+            if (results) {
+                return +results.groups.count;
+            }
+            return 0;
+        });
+    }
+    getPassIdpString(passIdp) {
+        return passIdp.toJSON(true).k;
+    }
+    createPassKeyBundle(password) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const passIdpParams = yield this.keyFactory.createPassIdpParams();
+            const passIdp = (yield this.keyFactory.derivePassIdp(Object.assign({ password }, passIdpParams))).jwk;
+            const passKeyParams = yield this.keyFactory.createPassKeyParams();
+            const passKey = (yield this.keyFactory.derivePassKey(Object.assign({ password }, passKeyParams))).jwk;
+            const passIdpVerifier = yield this.keyFactory.createPkcSignKey();
+            const wrappedPassIdpVerifierPrk = yield this.encryptionService.encrypt(passKey, passIdpVerifier.toJSON(true));
+            // There are two formats that the private key can be represented in JWK:
+            // https://tools.ietf.org/html/rfc8017#page-9
+            // The second form is an optimization:
+            // https://crypto.stackexchange.com/questions/19413/what-are-dp-and-dq-in-encryption-by-rsa-in-c
+            return {
+                passKeyParams,
+                passKey,
+                passIdpParams,
+                passIdp,
+                passIdpVerifier,
+                wrappedPassIdpVerifierPrk,
+            };
+        });
+    }
+    /**
+     * We need to allow for interruption of the process at any point. Each API call can be considered
+     * atomic and either succeeds or fails.
+     *
+     * The LR server APIs use semaphore tokens for locking critical operations, so concurrent calls will
+     * fail.
+     *
+     * We assume the worst case for IdP API calls. So we use the semaphore token from LR to prevent
+     * concurrent calls to IdP APIs, but we have to assume that the IdP API calls will either succeed or
+     * fail within a reasonable amount of time.
+     *
+     * Each location where the server state changes can be a potential point of interruption.
+     * Potential points of interruption are marked with: --Potential Failure Point--
+     *
+     * Places for timeout:
+     * - Login age too old at call to: verifyPassword()
+     * - Login age too old at call to: changePasswordMutation()
+     * - Semaphore token expires at call to: changePasswordComplete()
+     *
+     * Tests:
+     * - Potential Failure Point 1: should be able to restart the process, user remains signed in.
+     * - Potential Failure Point 2: should enter recovery flow
+     * - Potential Failure Point 3: should enter recovery flow
+     * - Potential Failure Point 4: should enter recovery flow
+     *
+     */
+    isLoginRequired() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const changePasswordConfig = yield this.getChangePasswordConfig();
+            const authTime = moment(changePasswordConfig.authTime);
+            const serverTime = moment(changePasswordConfig.serverTime);
+            const duration = moment.duration(serverTime.diff(authTime));
+            const seconds = duration.asSeconds();
+            if (seconds > changePasswordConfig.maxAuthAgeSeconds) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        });
+    }
+    changePassword(password, newPassword) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cognitoUser = yield this.auth.currentAuthenticatedUser();
+            // Not checking that passwords are different. It makes it easier to test.
+            const { currentUser } = yield this.profileService.getCurrentUser();
+            const { passIdp, signedChallenge } = yield this.verifyPassword(password, currentUser);
+            // --Potential Failure Point 1--
+            // verifyPassword() asks for a current password challenge hence changes server state.
+            // Place break points here to test the failure scenarios.
+            // Generate the new passIdp
+            const newPassKey = yield this.createPassKeyBundle(newPassword);
+            // Re-encrypt master key with new key
+            const masterKey = yield this.keyGraph.getKey(currentUser.currentUserKey.masterKey.id);
+            const newWrappedMasterKey = yield this.encryptionService.encrypt(newPassKey.passKey, masterKey.jwk.toJSON(true));
+            // If the IdP change password failed, we need to go into recovery mode by forcing
+            // a login. We can't logout the user just yet since the IdP password change needs
+            // the user to be logged in. We _can_ removed any persisted session values for the IdP
+            // but that seems like too much trouble.
+            const { token, newPassKeyId } = yield this.changePasswordMutation(signedChallenge, currentUser.currentUserKey.masterKey.id, newWrappedMasterKey, newPassKey);
+            // --Potential Failure Point 2--
+            // changePasswordMutation() uploads new keys and obtains a semaphore lock to prevent any other
+            // clients from performing IdP password change.
+            // Now we can do the IdP password change.
+            // todo: Add this back in
+            yield this.auth.changePassword(cognitoUser, this.getPassIdpString(passIdp), this.getPassIdpString(newPassKey.passIdp));
+            // --Potential Failure Point 3--
+            // IdP password change
+            // Note that changePassword() could throw an exception for a number of reason. It could throw
+            // a network timeout for example. But we don't know if it's the response that timed out and
+            // the idp password change was actually carried out. So we have to be extra conservative and
+            // only act on a clear success. Otherwise we go into recover mode.
+            yield this.changePasswordComplete(cognitoUser.getSignInUserSession().getAccessToken().getJwtToken(), true, token);
+        });
+    }
+    changePasswordComplete(accessToken, useNewPassword, token = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.http
+                .post(`${this.config.authUrl}users/password-change-complete/`, Object.assign({ use_new_password: useNewPassword }, (token && { token })), {
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            })
+                .toPromise();
+        });
+    }
+    getVerifierPrK(passKey, wrappedPrK) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const prkJson = yield this.encryptionService.decrypt(passKey, wrappedPrK);
+                return KFS.asKey(prkJson);
+            }
+            catch (error) {
+                throw new LrAuthException('Wrong current password');
+            }
+        });
+    }
+    verifyPassword(password, currentUser) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get information from the server to prepare for password change.
+            const passwordRequest = yield this.apollo.mutate({
+                mutation: PasswordChangeRequestMutation,
+                variables: {},
+            });
+            // Get the old passKey so we can decrypt the old password verifier
+            const passKeyResult = yield this.keyFactory.derivePassKey(Object.assign({ password }, currentUser.currentUserKey.passKey.passKeyParams));
+            const verifierPrK = yield this.getVerifierPrK(passKeyResult.jwk, currentUser.currentUserKey.passKey.wrappedPassIdpVerifierPrk);
+            // Sign the server challenge to prove to the server we can decrypt the password verifier.
+            // Generate
+            const clientNonce = this.keyFactory.randomString(this.CLIENT_NONCE_LENGTH);
+            const signedChallenge = yield this.encryptionService.sign(verifierPrK, {
+                serverNonce: passwordRequest.passwordChangeRequest.challenge.serverNonce,
+                clientNonce,
+            });
+            const passIdpResult = yield this.keyFactory.derivePassIdp(Object.assign({ password }, currentUser.currentUserKey.passKey.passIdpParams));
+            return {
+                passIdp: passIdpResult.jwk,
+                signedChallenge,
+            };
+        });
+    }
+    changePasswordMutation(signedChallenge, masterKeyId, newWrappedMasterKey, passKeyBundle) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.apollo.mutate({
+                mutation: PasswordChangeMutation,
+                variables: {
+                    input: {
+                        signedChallenge: JSON.stringify(signedChallenge),
+                        masterKeyId,
+                        newWrappedMasterKey: JSON.stringify(newWrappedMasterKey),
+                        newPassKey: {
+                            passIdpParams: JSON.stringify(passKeyBundle.passIdpParams),
+                            passIdpVerifierPbk: JSON.stringify(passKeyBundle.passIdpVerifier.toJSON()),
+                            wrappedPassIdpVerifierPrk: JSON.stringify(passKeyBundle.wrappedPassIdpVerifierPrk),
+                            passKeyParams: JSON.stringify(passKeyBundle.passKeyParams),
+                        },
+                    },
+                },
+            });
+            return {
+                token: response.passwordChange.token,
+                newPassKeyId: response.passwordChange.newPassKey.id,
+            };
+        });
+    }
+    getChangePasswordConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.apollo.query({
+                query: PasswordChangeConfigQuery,
+            });
+            const ret = res.passwordChangeConfig;
+            ret.authTime = new Date(ret.authTime);
+            ret.serverTime = new Date(ret.serverTime);
+            return ret;
+        });
+    }
+    passwordStrength(password) {
+        const upper = /[A-Z]/g;
+        const lower = /[a-z]/g;
+        const digit = /[0-9]/g;
+        const upperChoices = 26;
+        const lowerChoices = 26;
+        const digitChoices = 10;
+        const specialChoices = 30; // /[!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~]/g
+        function instanceCount(str, re) {
+            return ((str || '').match(re) || []).length;
+        }
+        const uppers = instanceCount(password, upper);
+        const lowers = instanceCount(password, lower);
+        const digits = instanceCount(password, digit);
+        const specials = password.length - uppers - lowers - digits;
+        let choices = 0;
+        if (uppers) {
+            choices += upperChoices;
+        }
+        if (lowers) {
+            choices += lowerChoices;
+        }
+        if (digits) {
+            choices += digitChoices;
+        }
+        if (specials) {
+            choices += specialChoices;
+        }
+        if (password.length === 0) {
+            return {
+                years: 0,
+                // bits of entropy
+                bits: 0,
+            };
+        }
+        const permutations = Math.pow(choices, password.length);
+        const years = (54000 * permutations) /
+            Math.pow(upperChoices + lowerChoices + digitChoices, 12);
+        return {
+            years,
+            // bits of entropy
+            bits: Math.round(Math.log2(permutations)),
+        };
+    }
+}
+PasswordService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PasswordService_Factory() { return new PasswordService(i0.ɵɵinject(i1.LR_CONFIG), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(i3.LrApolloService), i0.ɵɵinject(i4.AuthClass), i0.ɵɵinject(i5.ProfileService), i0.ɵɵinject(i6.KeyFactoryService), i0.ɵɵinject(i7.EncryptionService), i0.ɵɵinject(i8.KeyGraphService), i0.ɵɵinject(i9.WebCryptoService), i0.ɵɵinject(i10.IdleService)); }, token: PasswordService, providedIn: "root" });
+PasswordService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+PasswordService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LR_CONFIG,] }] },
+    { type: HttpClient },
+    { type: LrApolloService },
+    { type: AuthClass },
+    { type: ProfileService },
+    { type: KFS },
+    { type: EncryptionService },
+    { type: KeyGraphService },
+    { type: WebCryptoService },
+    { type: IdleService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"password.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/password/password.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Inject, Injectable } from '@angular/core';\nimport { CognitoUser } from '@aws-amplify/auth';\nimport { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';\nimport * as moment_ from 'moment';\nimport { Duration } from 'moment';\nimport { JWK, JWS } from 'node-jose';\nimport { PassKeyBundle } from '../auth/auth.types';\nimport { EncryptionService } from '../encryption/encryption.service';\nimport { IdleService } from '../idle/idle.service';\nimport { KeyFactoryService as KFS } from '../key/key-factory.service';\nimport { KeyGraphService } from '../key/key-graph.service';\nimport { LifeReadyConfig, LR_CONFIG } from '../life-ready.config';\nimport { ProfileService } from '../profile/profile.service';\nimport { ApiCurrentUser } from '../profile/profile.types';\nimport { WebCryptoService } from '../web-crypto/web-crypto.service';\nimport { LrAuthException } from '../_common/exceptions';\nimport { LrApolloService } from './../api/lr-apollo.service';\nimport {\n  PasswordChangeConfigQuery,\n  PasswordChangeMutation,\n  PasswordChangeRequestMutation,\n} from './password.gql';\n\n// \"why?\" you ask: https://stackoverflow.com/questions/59735280/angular-8-moment-error-cannot-call-a-namespace-moment\nconst moment = moment_;\n\ninterface PasswordChangeRequestMutation {\n  passwordChangeRequest: {\n    challenge: {\n      serverNonce: string;\n    };\n  };\n}\n\ninterface PasswordChangeMutation {\n  passwordChange: {\n    token: string;\n    newPassKey: {\n      id: string;\n    };\n  };\n}\n\nexport interface PasswordChangeConfig {\n  maxAuthAgeSeconds: number;\n  authTime: string | Date;\n  serverTime: string | Date;\n}\n\nexport class PasswordCheck {\n  length?: number;\n  timeToCrack?: Duration;\n  passwordExposed?: number;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class PasswordService {\n  private readonly CLIENT_NONCE_LENGTH = 32;\n\n  constructor(\n    @Inject(LR_CONFIG) private config: LifeReadyConfig,\n    private http: HttpClient,\n    private apollo: LrApolloService,\n    private auth: AuthClass,\n    private profileService: ProfileService,\n    private keyFactory: KFS,\n    private encryptionService: EncryptionService,\n    private keyGraph: KeyGraphService,\n    private webCryptoService: WebCryptoService,\n    private idleService: IdleService\n  ) {}\n\n  public async checkPassword(password: string): Promise<PasswordCheck> {\n    const { years } = this.passwordStrength(password);\n\n    return {\n      length: password.length,\n      timeToCrack: moment.duration({ years }),\n      passwordExposed: await this.getExposureCount(password),\n    };\n  }\n\n  public async getExposureCount(password: string): Promise<number> {\n    const sha1Password = await this.webCryptoService.stringDigest(\n      'SHA-1',\n      password\n    );\n    const first5sha1 = sha1Password.substring(0, 5);\n\n    const response = await this.http\n      .get(`https://api.pwnedpasswords.com/range/${first5sha1}`, {\n        responseType: 'text',\n      })\n      .toPromise();\n\n    const results = new RegExp(\n      `^(?:${sha1Password.substring(5)}:)(?<count>\\\\d+)$`,\n      'im'\n    ).exec(response);\n\n    if (results) {\n      return +results.groups.count;\n    }\n    return 0;\n  }\n\n  public getPassIdpString(passIdp: JWK.Key) {\n    return (passIdp.toJSON(true) as any).k;\n  }\n\n  public async createPassKeyBundle(password: string): Promise<PassKeyBundle> {\n    const passIdpParams = await this.keyFactory.createPassIdpParams();\n    const passIdp = (\n      await this.keyFactory.derivePassIdp({\n        password,\n        ...passIdpParams,\n      })\n    ).jwk;\n\n    const passKeyParams = await this.keyFactory.createPassKeyParams();\n    const passKey = (\n      await this.keyFactory.derivePassKey({\n        password,\n        ...passKeyParams,\n      })\n    ).jwk;\n\n    const passIdpVerifier = await this.keyFactory.createPkcSignKey();\n\n    const wrappedPassIdpVerifierPrk = await this.encryptionService.encrypt(\n      passKey,\n      passIdpVerifier.toJSON(true)\n    );\n\n    // There are two formats that the private key can be represented in JWK:\n    // https://tools.ietf.org/html/rfc8017#page-9\n    // The second form is an optimization:\n    // https://crypto.stackexchange.com/questions/19413/what-are-dp-and-dq-in-encryption-by-rsa-in-c\n\n    return {\n      passKeyParams,\n      passKey,\n      passIdpParams,\n      passIdp,\n      passIdpVerifier,\n      wrappedPassIdpVerifierPrk,\n    };\n  }\n\n  /**\n   * We need to allow for interruption of the process at any point. Each API call can be considered\n   * atomic and either succeeds or fails.\n   *\n   * The LR server APIs use semaphore tokens for locking critical operations, so concurrent calls will\n   * fail.\n   *\n   * We assume the worst case for IdP API calls. So we use the semaphore token from LR to prevent\n   * concurrent calls to IdP APIs, but we have to assume that the IdP API calls will either succeed or\n   * fail within a reasonable amount of time.\n   *\n   * Each location where the server state changes can be a potential point of interruption.\n   * Potential points of interruption are marked with: --Potential Failure Point--\n   *\n   * Places for timeout:\n   * - Login age too old at call to: verifyPassword()\n   * - Login age too old at call to: changePasswordMutation()\n   * - Semaphore token expires at call to: changePasswordComplete()\n   *\n   * Tests:\n   * - Potential Failure Point 1: should be able to restart the process, user remains signed in.\n   * - Potential Failure Point 2: should enter recovery flow\n   * - Potential Failure Point 3: should enter recovery flow\n   * - Potential Failure Point 4: should enter recovery flow\n   *\n   */\n\n  public async isLoginRequired(): Promise<boolean> {\n    const changePasswordConfig = await this.getChangePasswordConfig();\n    const authTime = moment(changePasswordConfig.authTime);\n    const serverTime = moment(changePasswordConfig.serverTime);\n    const duration = moment.duration(serverTime.diff(authTime));\n    const seconds = duration.asSeconds();\n    if (seconds > changePasswordConfig.maxAuthAgeSeconds) {\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  public async changePassword(password: string, newPassword: string) {\n    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();\n\n    // Not checking that passwords are different. It makes it easier to test.\n    const { currentUser } = await this.profileService.getCurrentUser();\n\n    const { passIdp, signedChallenge } = await this.verifyPassword(\n      password,\n      currentUser\n    );\n\n    // --Potential Failure Point 1--\n    // verifyPassword() asks for a current password challenge hence changes server state.\n    // Place break points here to test the failure scenarios.\n\n    // Generate the new passIdp\n    const newPassKey = await this.createPassKeyBundle(newPassword);\n\n    // Re-encrypt master key with new key\n    const masterKey = await this.keyGraph.getKey(\n      currentUser.currentUserKey.masterKey.id\n    );\n    const newWrappedMasterKey = await this.encryptionService.encrypt(\n      newPassKey.passKey,\n      masterKey.jwk.toJSON(true)\n    );\n\n    // If the IdP change password failed, we need to go into recovery mode by forcing\n    // a login. We can't logout the user just yet since the IdP password change needs\n    // the user to be logged in. We _can_ removed any persisted session values for the IdP\n    // but that seems like too much trouble.\n\n    const { token, newPassKeyId } = await this.changePasswordMutation(\n      signedChallenge,\n      currentUser.currentUserKey.masterKey.id,\n      newWrappedMasterKey,\n      newPassKey\n    );\n\n    // --Potential Failure Point 2--\n    // changePasswordMutation() uploads new keys and obtains a semaphore lock to prevent any other\n    // clients from performing IdP password change.\n\n    // Now we can do the IdP password change.\n    // todo: Add this back in\n    await this.auth.changePassword(\n      cognitoUser,\n      this.getPassIdpString(passIdp),\n      this.getPassIdpString(newPassKey.passIdp)\n    );\n\n    // --Potential Failure Point 3--\n    // IdP password change\n\n    // Note that changePassword() could throw an exception for a number of reason. It could throw\n    // a network timeout for example. But we don't know if it's the response that timed out and\n    // the idp password change was actually carried out. So we have to be extra conservative and\n    // only act on a clear success. Otherwise we go into recover mode.\n    await this.changePasswordComplete(\n      cognitoUser.getSignInUserSession().getAccessToken().getJwtToken(),\n      true,\n      token\n    );\n  }\n\n  public async changePasswordComplete(\n    accessToken: string,\n    useNewPassword: boolean,\n    token: string = null\n  ): Promise<any> {\n    return this.http\n      .post(\n        `${this.config.authUrl}users/password-change-complete/`,\n        {\n          use_new_password: useNewPassword,\n          ...(token && { token }),\n        },\n        {\n          headers: {\n            Authorization: `Bearer ${accessToken}`,\n          },\n        }\n      )\n      .toPromise();\n  }\n\n  private async getVerifierPrK(\n    passKey: JWK.Key,\n    wrappedPrK: object\n  ): Promise<JWK.Key> {\n    try {\n      const prkJson = await this.encryptionService.decrypt(passKey, wrappedPrK);\n      return KFS.asKey(prkJson);\n    } catch (error) {\n      throw new LrAuthException('Wrong current password');\n    }\n  }\n\n  private async verifyPassword(\n    password: string,\n    currentUser: ApiCurrentUser\n  ): Promise<{ passIdp: JWK.Key; signedChallenge: JWS.CreateSignResult }> {\n    // Get information from the server to prepare for password change.\n    const passwordRequest =\n      await this.apollo.mutate<PasswordChangeRequestMutation>({\n        mutation: PasswordChangeRequestMutation,\n        variables: {},\n      });\n\n    // Get the old passKey so we can decrypt the old password verifier\n    const passKeyResult = await this.keyFactory.derivePassKey({\n      password,\n      ...currentUser.currentUserKey.passKey.passKeyParams,\n    });\n\n    const verifierPrK = await this.getVerifierPrK(\n      passKeyResult.jwk,\n      currentUser.currentUserKey.passKey.wrappedPassIdpVerifierPrk\n    );\n\n    // Sign the server challenge to prove to the server we can decrypt the password verifier.\n    // Generate\n    const clientNonce = this.keyFactory.randomString(this.CLIENT_NONCE_LENGTH);\n\n    const signedChallenge = await this.encryptionService.sign(verifierPrK, {\n      serverNonce: passwordRequest.passwordChangeRequest.challenge.serverNonce,\n      clientNonce,\n    });\n\n    const passIdpResult = await this.keyFactory.derivePassIdp({\n      password,\n      ...currentUser.currentUserKey.passKey.passIdpParams,\n    });\n\n    return {\n      passIdp: passIdpResult.jwk,\n      signedChallenge,\n    };\n  }\n\n  private async changePasswordMutation(\n    signedChallenge: JWS.CreateSignResult,\n    masterKeyId: string,\n    newWrappedMasterKey: object,\n    passKeyBundle: PassKeyBundle\n  ): Promise<{ token: string; newPassKeyId: string }> {\n    const response = await this.apollo.mutate<PasswordChangeMutation>({\n      mutation: PasswordChangeMutation,\n      variables: {\n        input: {\n          signedChallenge: JSON.stringify(signedChallenge),\n          masterKeyId,\n          newWrappedMasterKey: JSON.stringify(newWrappedMasterKey),\n          newPassKey: {\n            passIdpParams: JSON.stringify(passKeyBundle.passIdpParams),\n            passIdpVerifierPbk: JSON.stringify(\n              passKeyBundle.passIdpVerifier.toJSON()\n            ),\n            wrappedPassIdpVerifierPrk: JSON.stringify(\n              passKeyBundle.wrappedPassIdpVerifierPrk\n            ),\n            passKeyParams: JSON.stringify(passKeyBundle.passKeyParams),\n          },\n        },\n      },\n    });\n    return {\n      token: response.passwordChange.token,\n      newPassKeyId: response.passwordChange.newPassKey.id,\n    };\n  }\n\n  async getChangePasswordConfig(): Promise<PasswordChangeConfig> {\n    const res = await this.apollo.query<any>({\n      query: PasswordChangeConfigQuery,\n    });\n\n    const ret = res.passwordChangeConfig as PasswordChangeConfig;\n\n    ret.authTime = new Date(ret.authTime);\n    ret.serverTime = new Date(ret.serverTime);\n    return ret;\n  }\n\n  public passwordStrength(password): { years: number; bits: number } {\n    const upper = /[A-Z]/g;\n    const lower = /[a-z]/g;\n    const digit = /[0-9]/g;\n\n    const upperChoices = 26;\n    const lowerChoices = 26;\n    const digitChoices = 10;\n    const specialChoices = 30; // /[!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~]/g\n\n    function instanceCount(str, re) {\n      return ((str || '').match(re) || []).length;\n    }\n\n    const uppers = instanceCount(password, upper);\n    const lowers = instanceCount(password, lower);\n    const digits = instanceCount(password, digit);\n    const specials = password.length - uppers - lowers - digits;\n\n    let choices = 0;\n    if (uppers) {\n      choices += upperChoices;\n    }\n    if (lowers) {\n      choices += lowerChoices;\n    }\n    if (digits) {\n      choices += digitChoices;\n    }\n    if (specials) {\n      choices += specialChoices;\n    }\n\n    if (password.length === 0) {\n      return {\n        years: 0,\n        // bits of entropy\n        bits: 0,\n      };\n    }\n\n    const permutations = Math.pow(choices, password.length);\n\n    const years =\n      (54000 * permutations) /\n      Math.pow(upperChoices + lowerChoices + digitChoices, 12);\n    return {\n      years,\n      // bits of entropy\n      bits: Math.round(Math.log2(permutations)),\n    };\n  }\n}\n"]}