@lifeready/core 1.0.0 → 1.0.1

package/src/lib/auth/lbop.service.ts

@@ -0,0 +1,539 @@
+import { LrApolloService } from '../api/lr-apollo.service';
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import gql from 'graphql-tag';
+import { JWK } from 'node-jose';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyService } from '../cryptography/key.service';
+import { LifeReadyConfig, LR_CONFIG } from '../life-ready.config';
+import {
+  LrException,
+  LrErrorCode,
+  LrBadLogicException,
+} from '../_common/exceptions';
+import { LifeReadyAuthService } from './life-ready-auth.service';
+import { PasswordService } from './password.service';
+import { Slip39Helper } from 'slip39';
+import { KeyFactoryService as KFS } from '../cryptography/key-factory.service';
+
+interface SetPasswordApiResult {
+  username: string;
+  idpPassword: string;
+  setPasswordToken: string;
+}
+
+export interface SetPasswordParams {
+  lbopId: string;
+  newPassword: string;
+  verifiedToken: string;
+  masterKeyId: string;
+  masterKey: JWK.Key;
+}
+
+export interface VerifyContactParams {
+  email?: string;
+  phone?: string;
+}
+
+export interface VerifyContactResult {
+  // The claim_id identifies the Email/SMS confirmation
+  claimId: string;
+}
+
+export interface ConfirmContactParams {
+  claimId: string;
+  vCode: string;
+}
+
+export interface ConfirmContactResult {
+  // The token to prove the client had the correct confirmation code.
+  token: string;
+}
+
+export interface VerifyParams {
+  claimId: string;
+  claimToken: string;
+  lbop: string;
+}
+
+export interface VerifyResult {
+  // userId: string;
+  lbopId: string;
+  verifiedToken: string;
+  masterKeyId: string;
+  masterKey: JWK.Key;
+}
+
+export interface ChallengeResult {
+  challenge: any;
+  lbops: any;
+  // userId: string;
+}
+
+export interface Lbop {
+  id: string;
+  partial?: string;
+  name?: string;
+  lbopString?: string;
+}
+
+export interface CreateLbopParams {
+  name?: string;
+}
+
+interface CreateLbopQuery {
+  createLbop: {
+    lbop: Lbop;
+  };
+}
+
+export const CreateLbopQuery = gql`
+  mutation CreateLbop($input: CreateLbopInput!) {
+    createLbop(input: $input) {
+      lbop {
+        id
+      }
+    }
+  }
+`;
+
+interface DeleteLbopQuery {
+  deleteLbop: Lbop;
+}
+
+export const DeleteLbopQuery = gql`
+  mutation DeleteLbop($input: DeleteLbopInput!) {
+    deleteLbop(input: $input) {
+      id
+    }
+  }
+`;
+
+export interface UpdateLbopParams {
+  id: string;
+  name: string;
+}
+
+interface UpdateLbopQuery {
+  updateLbop: Lbop;
+}
+
+export const UpdateLbopQuery = gql`
+  mutation UpdateLbop($input: UpdateLbopInput!) {
+    updateLbop(input: $input) {
+      lbop {
+        id
+      }
+    }
+  }
+`;
+
+export const LbopQuery = gql`
+  query Lbop($id: LrRelayIdInput!) {
+    lbop(id: $id) {
+      id
+      cipherMeta
+    }
+  }
+`;
+
+interface LbopsQuery {
+  lbops: any;
+}
+
+export const LbopsQuery = gql`
+  query Lbops {
+    lbops {
+      edges {
+        node {
+          id
+          cipherMeta
+        }
+      }
+    }
+  }
+`;
+
+@Injectable({
+  providedIn: 'root',
+})
+export class LbopService {
+  private readonly CLIENT_NONCE_LENGTH = 32;
+  // There are 1024 words (10 bits), so 25 words should give ~256 bits of entropy.
+  private readonly LBOP_WORDS = 25;
+
+  constructor(
+    @Inject(LR_CONFIG) private config: LifeReadyConfig,
+    private http: HttpClient,
+    private lrApollo: LrApolloService,
+    private auth: AuthClass,
+    private authService: LifeReadyAuthService,
+    private keyFactory: KFS,
+    private keyService: KeyService,
+    private encryptionService: EncryptionService,
+    private keyGraph: KeyGraphService,
+    private passwordService: PasswordService
+  ) {}
+
+  private getPartial(lbopString: string): string {
+    return lbopString.split(' ')[0];
+  }
+
+  public async remove(id: string): Promise<string> {
+    const res = await this.lrApollo.mutate<any>({
+      mutation: DeleteLbopQuery,
+      variables: {
+        input: {
+          id,
+        },
+      },
+    });
+
+    return res.deleteLbop.id;
+  }
+
+  public async update({ id, name }: UpdateLbopParams): Promise<Lbop> {
+    const lbop = await this.get(id);
+    lbop.name = name;
+
+    const masterKey = await this.keyService.getCurrentMasterKey();
+    const cipherMeta = await this.encryptionService.encrypt(
+      masterKey.jwk,
+      lbop
+    );
+
+    const res = await this.lrApollo.mutate<UpdateLbopQuery>({
+      mutation: UpdateLbopQuery,
+      variables: {
+        input: {
+          id,
+          cipherMeta: JSON.stringify(cipherMeta),
+        },
+      },
+    });
+
+    return res.updateLbop;
+  }
+
+  public async get(id: string): Promise<Lbop> {
+    const res = await this.lrApollo.query<any>({
+      query: LbopQuery,
+      variables: {
+        id,
+      },
+    });
+
+    const masterKey = await this.keyService.getCurrentMasterKey();
+
+    const plainCipherMeta = await this.encryptionService.decrypt(
+      masterKey.jwk,
+      JSON.parse(res.lbop.cipherMeta)
+    );
+
+    return {
+      id: res.id,
+      ...plainCipherMeta,
+    };
+  }
+
+  public async list(): Promise<Lbop[]> {
+    const res = await this.lrApollo.query<LbopsQuery>({
+      query: LbopsQuery,
+    });
+
+    const masterKey = await this.keyService.getCurrentMasterKey();
+
+    return Promise.all(
+      res.lbops.edges.map(async (edge) => {
+        const plainCipherMeta = await this.encryptionService.decrypt(
+          masterKey.jwk,
+          JSON.parse(edge.node.cipherMeta)
+        );
+        return {
+          id: edge.node.id,
+          ...plainCipherMeta,
+        };
+      })
+    );
+  }
+
+  public async create({ name }: CreateLbopParams): Promise<Lbop> {
+    if (Slip39Helper.WORD_LIST.length !== 1024) {
+      throw new LrBadLogicException('Slip39Helper.WORD_LIST.length != 1024');
+    }
+
+    // Get existing to make sure there are not duplicate first words
+    const lbops = await this.list();
+
+    // Generate new one
+    let lbopString;
+    while (true) {
+      lbopString = this.keyFactory
+        .randomChoices(Slip39Helper.WORD_LIST, this.LBOP_WORDS)
+        .join(' ');
+      const partial = this.getPartial(lbopString);
+
+      if (!lbops.some((lbop) => lbop.partial === partial)) {
+        break;
+      }
+    }
+
+    const lbopKeyParams = await this.keyFactory.createLbopKeyParams();
+    const lbopKey = (
+      await this.keyFactory.deriveLbopKey({
+        password: lbopString,
+        ...lbopKeyParams,
+      })
+    ).jwk;
+
+    const lbopKeyVerifier = await this.keyFactory.createSignKey();
+    const wrappedLbopKeyVerifier = await this.encryptionService.encrypt(
+      lbopKey,
+      lbopKeyVerifier.toJSON(true)
+    );
+
+    // Re-encrypt master key with new key
+    const currentUser = await this.authService.getUser();
+    const masterKey = await this.keyGraph.getKey(
+      currentUser.currentUserKey.masterKey.id
+    );
+    const wrappedMasterKey = await this.encryptionService.encrypt(
+      lbopKey,
+      masterKey.jwk.toJSON(true)
+    );
+
+    const meta = {
+      ...(name && { name }),
+      partial: this.getPartial(lbopString),
+    };
+    const cipherMeta = await this.encryptionService.encrypt(
+      masterKey.jwk,
+      meta
+    );
+
+    const res = await this.lrApollo.mutate<CreateLbopQuery>({
+      mutation: CreateLbopQuery,
+      variables: {
+        input: {
+          cipherMeta: JSON.stringify(cipherMeta),
+          lbopKeyParams: JSON.stringify(lbopKeyParams),
+          lbopKeyVerifier: JSON.stringify(lbopKeyVerifier.toJSON(true)),
+          wrappedLbopKeyVerifier: JSON.stringify(wrappedLbopKeyVerifier),
+          masterKeyId: currentUser.currentUserKey.masterKey.id,
+          wrappedMasterKey: JSON.stringify(wrappedMasterKey),
+        },
+      },
+    });
+
+    return {
+      ...res.createLbop.lbop,
+      lbopString,
+    };
+  }
+
+  // --------------------------------------------------------------------------------------------------------------------
+  // --------------------------------------------------------------------------------------------------------------------
+  // Flow below are for password reset via LBOP
+  //
+  // --Potential Failure Point xxx--
+  //
+  // Look for the above and you can test by interrupting at these points.
+  //
+  // The LBOP reset process can be restarted at any point before the call to "set-password/". Once "set-password/" has been
+  // called, we assume the client has a short period of time to change the Idp password to the one they've chosen. The "set-password/"
+  // will set the Idp password to a temporary random password. The user can no longer login using their current password. If the Idp
+  // password change process does not complete or takes longer than the lockout period, the account will not be accessible and a new
+  // LBOP password reset must be carried out.
+  // --------------------------------------------------------------------------------------------------------------------
+  // --------------------------------------------------------------------------------------------------------------------
+  private async verifyLbops(
+    challengeResult: ChallengeResult,
+    lbopString: string
+  ): Promise<{ lbop: any; signedChallenge: any; lbopKey: JWK.Key }> {
+    const clientNonce = this.keyFactory.randomString(this.CLIENT_NONCE_LENGTH);
+
+    for (const lbop of challengeResult.lbops) {
+      const lbopKey = (
+        await this.keyFactory.deriveLbopKey({
+          password: lbopString,
+          ...lbop.lbopKeyParams,
+        })
+      ).jwk;
+
+      // If decoding successful then it's the correct lbop
+      try {
+        const lbopKeyVerifier = (await this.encryptionService.decrypt(
+          lbopKey,
+          lbop.wrappedLbopKeyVerifier
+        )) as any;
+
+        // Force a bad signature.
+        // const serverNonce = challengeResult.challenge.serverNonce + "1",
+
+        const serverNonce = challengeResult.challenge.serverNonce;
+
+        const signedChallenge = await this.encryptionService.sign(
+          lbopKeyVerifier,
+          {
+            serverNonce,
+            clientNonce,
+          }
+        );
+
+        return {
+          lbop,
+          signedChallenge,
+          lbopKey,
+        };
+      } catch (error) {
+        continue;
+      }
+    }
+    throw new LrException({
+      source: 'LBOP',
+      code: 'INVALID_PASSPHRASE',
+      message: 'Invalid passphrase.',
+    });
+  }
+
+  public async verifyContact(
+    params: VerifyContactParams
+  ): Promise<VerifyContactResult> {
+    const ret = this.http
+      .post<VerifyContactResult>(
+        `${this.config.authUrl}users/lbop-reset/verify-contact/`,
+        params
+      )
+      .toPromise();
+
+    // --Potential Failure Point 1 --
+    // The contact verifications are throttled. But otherwise harmless.
+
+    return ret;
+  }
+
+  public async confirmContact(
+    params: ConfirmContactParams
+  ): Promise<ConfirmContactResult> {
+    return this.http
+      .post<ConfirmContactResult>(`${this.config.authUrl}cove/respond/`, {
+        claim_id: params.claimId,
+        v_code: params.vCode,
+      })
+      .toPromise();
+
+    // --Potential Failure Point 2 --
+    // A verified claim for a contact does not prevent new ones from being generated. So it should be fine to just start again.
+  }
+
+  public async verify(params: VerifyParams): Promise<VerifyResult> {
+    const challengeResult = await this.http
+      .post<ChallengeResult>(
+        `${this.config.authUrl}users/lbop-reset/get-challenge/`,
+        {
+          claimId: params.claimId,
+          claimToken: params.claimToken,
+        }
+      )
+      .toPromise();
+
+    // --Potential Failure Point 3 --
+    // This does not lock anything. A second call to "get-challenge/" will create a new challenge amd invalidate the first one.
+    const { signedChallenge, lbop, lbopKey } = await this.verifyLbops(
+      challengeResult,
+      params.lbop
+    );
+
+    const res = await this.http
+      .post<any>(`${this.config.authUrl}users/lbop-reset/verify-challenge/`, {
+        lbopId: lbop.lbopId,
+        signedChallenge,
+      })
+      .toPromise();
+
+    // --Potential Failure Point 4 --
+    // This does not lock anything. So ok to restart.
+
+    return {
+      lbopId: lbop.lbopId,
+      verifiedToken: res.verifiedToken,
+      masterKeyId: res.masterKeyId,
+      masterKey: await KFS.asKey(
+        await this.encryptionService.decrypt(lbopKey, res.wrappedMasterKey)
+      ),
+    };
+  }
+
+  public async setPassword(params: SetPasswordParams): Promise<any> {
+    // Generate the new password derived keys
+    const passKeyBundle = await this.passwordService.createPassKeyBundle(
+      params.newPassword
+    );
+
+    // Re-encrypt master key with new key
+    const newWrappedMasterKey = await this.encryptionService.encrypt(
+      passKeyBundle.passKey,
+      params.masterKey.toJSON(true)
+    );
+
+    const result = await this.http
+      .post<SetPasswordApiResult>(
+        `${this.config.authUrl}users/lbop-reset/set-password/`,
+        {
+          lbopId: params.lbopId,
+          verifiedToken: params.verifiedToken,
+          masterKeyId: params.masterKeyId,
+          newWrappedMasterKey,
+          newPassKey: {
+            passKeyParams: passKeyBundle.passKeyParams,
+            passIdpParams: passKeyBundle.passIdpParams,
+            passIdpVerifierPbk: passKeyBundle.passIdpVerifier.toJSON(),
+            wrappedPassIdpVerifierPrk: passKeyBundle.wrappedPassIdpVerifierPrk,
+          },
+        }
+      )
+      .toPromise();
+
+    // --Potential Failure Point 5 --
+    // A timed mutex is locked. The Idp password change must occur within a period of time.
+    // If interrupted here, the user can not login with their old password again. They must
+    // start the whole LBOP password reset process again.
+
+    // This call will go through the LR proxy which is OK since the LR server knows
+    // the temporary password anyway.
+    let user = await this.auth.signIn(result.username, result.idpPassword, {
+      noProxy: 'true',
+    });
+
+    if (user.challengeName !== 'NEW_PASSWORD_REQUIRED') {
+      throw new LrException({
+        message:
+          'Internal error. Expecting Cognito to have done a password reset.',
+      });
+    }
+
+    // --Potential Failure Point 6 --
+    // Must restart the LBOP password reset process again.
+
+    // Set new password on Idp
+    user = await this.auth.completeNewPassword(
+      user,
+      this.passwordService.getPassIdpString(passKeyBundle.passIdp),
+      {}
+    );
+
+    // --Potential Failure Point 7 --
+    // Must restart the LBOP password reset process again.
+
+    await this.auth.signOut();
+
+    return await this.http
+      .post<any>(`${this.config.authUrl}users/lbop-reset/complete/`, {
+        lbopId: params.lbopId,
+        setPasswordToken: result.setPasswordToken,
+      })
+      .toPromise();
+  }
+}

package/src/lib/auth/life-ready-auth.service.spec.ts

@@ -0,0 +1,70 @@
+import { TestBed } from '@angular/core/testing';
+import { LifeReadyAuthService } from './life-ready-auth.service';
+import { CurrentUser } from '../../public-api';
+import { environment } from 'projects/lr-auth-app/src/environments/environment';
+import { lrConfigureTestingModule } from '../_common/tests';
+
+describe('LifeReadyAuthService', () => {
+  let service: LifeReadyAuthService;
+
+  beforeEach(() => {
+    lrConfigureTestingModule();
+    service = TestBed.inject(LifeReadyAuthService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});
+
+export async function loginTestUser(
+  username?: string,
+  password?: string
+): Promise<CurrentUser> {
+  if (!environment.test) {
+    return;
+  }
+
+  if (!username || !password) {
+    username = environment.test.users[0].username;
+    password = environment.test.users[0].password;
+  }
+
+  const authService = TestBed.inject(LifeReadyAuthService);
+
+  const originalTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
+  jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000;
+  console.log(
+    `setting jasmine.DEFAULT_TIMEOUT_INTERVAL to ${jasmine.DEFAULT_TIMEOUT_INTERVAL}`
+  );
+
+  try {
+    try {
+      const user = await authService.getUser();
+      if (user.username === username || user.email === username) {
+        return user;
+      }
+    } catch (error) {
+      // nothing
+    }
+
+    await logoutUser();
+
+    console.log('Logging in test user.');
+
+    await authService.login(username, password);
+
+    // If there's 2FA then getUser() will throw.
+    return await authService.getUser();
+  } finally {
+    console.log(
+      `setting jasmine.DEFAULT_TIMEOUT_INTERVAL back to ${jasmine.DEFAULT_TIMEOUT_INTERVAL}`
+    );
+    jasmine.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
+  }
+}
+
+export async function logoutUser(): Promise<void> {
+  const authService = TestBed.inject(LifeReadyAuthService);
+  await authService.logout();
+}